// Generated from ques.g4 by ANTLR 4.2.2

	package queryfish.antlr.parser;

import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;

import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class quesParser extends Parser {
	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__86=1, T__85=2, T__84=3, T__83=4, T__82=5, T__81=6, T__80=7, T__79=8, 
		T__78=9, T__77=10, T__76=11, T__75=12, T__74=13, T__73=14, T__72=15, T__71=16, 
		T__70=17, T__69=18, T__68=19, T__67=20, T__66=21, T__65=22, T__64=23, 
		T__63=24, T__62=25, T__61=26, T__60=27, T__59=28, T__58=29, T__57=30, 
		T__56=31, T__55=32, T__54=33, T__53=34, T__52=35, T__51=36, T__50=37, 
		T__49=38, T__48=39, T__47=40, T__46=41, T__45=42, T__44=43, T__43=44, 
		T__42=45, T__41=46, T__40=47, T__39=48, T__38=49, T__37=50, T__36=51, 
		T__35=52, T__34=53, T__33=54, T__32=55, T__31=56, T__30=57, T__29=58, 
		T__28=59, T__27=60, T__26=61, T__25=62, T__24=63, T__23=64, T__22=65, 
		T__21=66, T__20=67, T__19=68, T__18=69, T__17=70, T__16=71, T__15=72, 
		T__14=73, T__13=74, T__12=75, T__11=76, T__10=77, T__9=78, T__8=79, T__7=80, 
		T__6=81, T__5=82, T__4=83, T__3=84, T__2=85, T__1=86, T__0=87, WS=88, 
		D=89, A=90, N1=91, N2=92, N3=93;
	public static final String[] tokenNames = {
		"<INVALID>", "'tầng nước sống'", "'tên khoa học'", "'những'", "'đặc điểm sinh học'", 
		"'khu vực nào'", "'nêu'", "'chiều dài cá trung bình'", "'chiều dài'", 
		"'nhiệt độ nước'", "'tên kiểu hình'", "'nước'", "'thuộc'", "'nhiệt độ'", 
		"'thế nào'", "'chăm'", "'phân bố'", "'bộ'", "'trong'", "'hướng dẫn'", 
		"'pH'", "'như thế nào'", "'hướng'", "'nguồn gốc'", "'cho biết'", "'yêu cầu lọc nước'", 
		"'tên tiếng anh khác'", "'kích thước trung bình cá'", "'độ pH'", "'từ đâu'", 
		"'họ'", "'ở đâu'", "'sinh sản'", "'yêu cầu ánh sáng'", "'gì'", "'phân loại'", 
		"'đặc tính sinh sản'", "'chăm sóc'", "'độ dH'", "'tên tiếng việt khác'", 
		"'là'", "'thiết kế bể'", "'kích thước trung bình'", "'chiều dài trung bình cá'", 
		"'của'", "'hãy nêu'", "'nuôi'", "'thiết kế'", "'yêu cầu hồ rong'", "'hãy cho biết'", 
		"'kích thước'", "'chiều dài trung bình'", "'cho'", "'?'", "'thức ăn'", 
		"'dH'", "'nào thế'", "'được'", "'sống'", "'thông tin chung'", "'nào'", 
		"'độ cứng nước'", "'đặc điểm'", "'tên tiếng việt'", "'thông tin'", "'loại thức ăn'", 
		"'có'", "'ăn'", "'loài'", "'chi tiết phân loại'", "'tên đồng danh'", "'yêu cầu sục khí'", 
		"'có thể'", "'chiều dài cá'", "'để'", "'bộ cá'", "'cách nuôi'", "'tên phổ biến'", 
		"'cá'", "'họ cá'", "'kích thước cá trung bình'", "'bao nhiêu'", "'bể'", 
		"'kích thước cá'", "'loài cá'", "'cần'", "'kỹ thuật nuôi'", "'tên tiếng anh'", 
		"WS", "D", "A", "N1", "N2", "N3"
	};
	public static final int
		RULE_scienceName = 0, RULE_sameName = 1, RULE_engName = 2, RULE_vnName = 3, 
		RULE_imageName = 4, RULE_commonName = 5, RULE_name = 6, RULE_mossRequest = 7, 
		RULE_lightRequest = 8, RULE_waterFilterRequest = 9, RULE_aerationRequest = 10, 
		RULE_request = 11, RULE_waterTemparature = 12, RULE_dH = 13, RULE_pH = 14, 
		RULE_waterRequest = 15, RULE_fishSet = 16, RULE_fishClass = 17, RULE_kindOfFish = 18, 
		RULE_subspecies = 19, RULE_longFish = 20, RULE_orgination = 21, RULE_distribution = 22, 
		RULE_waterField = 23, RULE_designAquarium = 24, RULE_kindOfFood = 25, 
		RULE_caring = 26, RULE_generalInfo = 27, RULE_biology = 28, RULE_cultureTech = 29, 
		RULE_repronduction = 30, RULE_classification = 31, RULE_verbPharseStartQues1 = 32, 
		RULE_verbPharseStartQues2 = 33, RULE_verbPharseStartQues3 = 34, RULE_iN = 35, 
		RULE_inIn = 36, RULE_inCan = 37, RULE_inFor = 38, RULE_nnFish = 39, RULE_nnAquarium = 40, 
		RULE_nnWater = 41, RULE_vbBe = 42, RULE_vbHave = 43, RULE_vbOf = 44, RULE_vbLive = 45, 
		RULE_vbFeed = 46, RULE_vbGet = 47, RULE_vbEat = 48, RULE_vbNeed = 49, 
		RULE_advTo = 50, RULE_dtThe = 51, RULE_where01 = 52, RULE_where02 = 53, 
		RULE_expletive01 = 54, RULE_expletive02 = 55, RULE_expletive03 = 56, RULE_expletive04 = 57, 
		RULE_expletive05 = 58, RULE_expletive06 = 59, RULE_expletive07 = 60, RULE_endQues01 = 61, 
		RULE_endQues02 = 62, RULE_endQues03 = 63, RULE_endQues04 = 64, RULE_endQues05 = 65, 
		RULE_endQues06 = 66, RULE_endQues07 = 67, RULE_endQues08 = 68, RULE_nameFish = 69, 
		RULE_info01 = 70, RULE_info02 = 71, RULE_questionWh01 = 72, RULE_questionWh02 = 73, 
		RULE_questionWh03 = 74, RULE_questionWh04 = 75, RULE_questionWh05 = 76, 
		RULE_questionWh06 = 77, RULE_questionWh07 = 78, RULE_questionWh08 = 79, 
		RULE_questionWh09 = 80, RULE_questionWh10 = 81, RULE_questionWh11 = 82, 
		RULE_questionWh12 = 83, RULE_questionWh13 = 84, RULE_questionWh14 = 85, 
		RULE_questionWh15 = 86, RULE_questionWh16 = 87, RULE_questionWh17 = 88, 
		RULE_questionWh18 = 89, RULE_questionWh19 = 90, RULE_questionWh20 = 91, 
		RULE_question = 92;
	public static final String[] ruleNames = {
		"scienceName", "sameName", "engName", "vnName", "imageName", "commonName", 
		"name", "mossRequest", "lightRequest", "waterFilterRequest", "aerationRequest", 
		"request", "waterTemparature", "dH", "pH", "waterRequest", "fishSet", 
		"fishClass", "kindOfFish", "subspecies", "longFish", "orgination", "distribution", 
		"waterField", "designAquarium", "kindOfFood", "caring", "generalInfo", 
		"biology", "cultureTech", "repronduction", "classification", "verbPharseStartQues1", 
		"verbPharseStartQues2", "verbPharseStartQues3", "iN", "inIn", "inCan", 
		"inFor", "nnFish", "nnAquarium", "nnWater", "vbBe", "vbHave", "vbOf", 
		"vbLive", "vbFeed", "vbGet", "vbEat", "vbNeed", "advTo", "dtThe", "where01", 
		"where02", "expletive01", "expletive02", "expletive03", "expletive04", 
		"expletive05", "expletive06", "expletive07", "endQues01", "endQues02", 
		"endQues03", "endQues04", "endQues05", "endQues06", "endQues07", "endQues08", 
		"nameFish", "info01", "info02", "questionWh01", "questionWh02", "questionWh03", 
		"questionWh04", "questionWh05", "questionWh06", "questionWh07", "questionWh08", 
		"questionWh09", "questionWh10", "questionWh11", "questionWh12", "questionWh13", 
		"questionWh14", "questionWh15", "questionWh16", "questionWh17", "questionWh18", 
		"questionWh19", "questionWh20", "question"
	};

	@Override
	public String getGrammarFileName() { return "ques.g4"; }

	@Override
	public String[] getTokenNames() { return tokenNames; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public ATN getATN() { return _ATN; }

	public quesParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class ScienceNameContext extends ParserRuleContext {
		public ScienceNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_scienceName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterScienceName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitScienceName(this);
		}
	}

	public final ScienceNameContext scienceName() throws RecognitionException {
		ScienceNameContext _localctx = new ScienceNameContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_scienceName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(186); match(2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SameNameContext extends ParserRuleContext {
		public SameNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sameName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterSameName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitSameName(this);
		}
	}

	public final SameNameContext sameName() throws RecognitionException {
		SameNameContext _localctx = new SameNameContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_sameName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(188); match(70);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EngNameContext extends ParserRuleContext {
		public EngNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_engName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterEngName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitEngName(this);
		}
	}

	public final EngNameContext engName() throws RecognitionException {
		EngNameContext _localctx = new EngNameContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_engName);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(190);
			_la = _input.LA(1);
			if ( !(_la==26 || _la==87) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VnNameContext extends ParserRuleContext {
		public VnNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vnName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVnName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVnName(this);
		}
	}

	public final VnNameContext vnName() throws RecognitionException {
		VnNameContext _localctx = new VnNameContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_vnName);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(192);
			_la = _input.LA(1);
			if ( !(_la==39 || _la==63) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ImageNameContext extends ParserRuleContext {
		public ImageNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_imageName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterImageName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitImageName(this);
		}
	}

	public final ImageNameContext imageName() throws RecognitionException {
		ImageNameContext _localctx = new ImageNameContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_imageName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(194); match(10);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CommonNameContext extends ParserRuleContext {
		public CommonNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_commonName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterCommonName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitCommonName(this);
		}
	}

	public final CommonNameContext commonName() throws RecognitionException {
		CommonNameContext _localctx = new CommonNameContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_commonName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(196); match(77);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NameContext extends ParserRuleContext {
		public ScienceNameContext scienceName() {
			return getRuleContext(ScienceNameContext.class,0);
		}
		public SameNameContext sameName() {
			return getRuleContext(SameNameContext.class,0);
		}
		public EngNameContext engName() {
			return getRuleContext(EngNameContext.class,0);
		}
		public ImageNameContext imageName() {
			return getRuleContext(ImageNameContext.class,0);
		}
		public CommonNameContext commonName() {
			return getRuleContext(CommonNameContext.class,0);
		}
		public VnNameContext vnName() {
			return getRuleContext(VnNameContext.class,0);
		}
		public NameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitName(this);
		}
	}

	public final NameContext name() throws RecognitionException {
		NameContext _localctx = new NameContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_name);
		try {
			setState(204);
			switch (_input.LA(1)) {
			case 2:
				enterOuterAlt(_localctx, 1);
				{
				setState(198); scienceName();
				}
				break;
			case 70:
				enterOuterAlt(_localctx, 2);
				{
				setState(199); sameName();
				}
				break;
			case 26:
			case 87:
				enterOuterAlt(_localctx, 3);
				{
				setState(200); engName();
				}
				break;
			case 39:
			case 63:
				enterOuterAlt(_localctx, 4);
				{
				setState(201); vnName();
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 5);
				{
				setState(202); imageName();
				}
				break;
			case 77:
				enterOuterAlt(_localctx, 6);
				{
				setState(203); commonName();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MossRequestContext extends ParserRuleContext {
		public MossRequestContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mossRequest; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterMossRequest(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitMossRequest(this);
		}
	}

	public final MossRequestContext mossRequest() throws RecognitionException {
		MossRequestContext _localctx = new MossRequestContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_mossRequest);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(206); match(48);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LightRequestContext extends ParserRuleContext {
		public LightRequestContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lightRequest; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterLightRequest(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitLightRequest(this);
		}
	}

	public final LightRequestContext lightRequest() throws RecognitionException {
		LightRequestContext _localctx = new LightRequestContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_lightRequest);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(208); match(33);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WaterFilterRequestContext extends ParserRuleContext {
		public WaterFilterRequestContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_waterFilterRequest; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterWaterFilterRequest(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitWaterFilterRequest(this);
		}
	}

	public final WaterFilterRequestContext waterFilterRequest() throws RecognitionException {
		WaterFilterRequestContext _localctx = new WaterFilterRequestContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_waterFilterRequest);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(210); match(25);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AerationRequestContext extends ParserRuleContext {
		public AerationRequestContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aerationRequest; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterAerationRequest(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitAerationRequest(this);
		}
	}

	public final AerationRequestContext aerationRequest() throws RecognitionException {
		AerationRequestContext _localctx = new AerationRequestContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_aerationRequest);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(212); match(71);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RequestContext extends ParserRuleContext {
		public LightRequestContext lightRequest() {
			return getRuleContext(LightRequestContext.class,0);
		}
		public MossRequestContext mossRequest() {
			return getRuleContext(MossRequestContext.class,0);
		}
		public WaterFilterRequestContext waterFilterRequest() {
			return getRuleContext(WaterFilterRequestContext.class,0);
		}
		public AerationRequestContext aerationRequest() {
			return getRuleContext(AerationRequestContext.class,0);
		}
		public RequestContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_request; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterRequest(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitRequest(this);
		}
	}

	public final RequestContext request() throws RecognitionException {
		RequestContext _localctx = new RequestContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_request);
		try {
			setState(218);
			switch (_input.LA(1)) {
			case 48:
				enterOuterAlt(_localctx, 1);
				{
				setState(214); mossRequest();
				}
				break;
			case 33:
				enterOuterAlt(_localctx, 2);
				{
				setState(215); lightRequest();
				}
				break;
			case 25:
				enterOuterAlt(_localctx, 3);
				{
				setState(216); waterFilterRequest();
				}
				break;
			case 71:
				enterOuterAlt(_localctx, 4);
				{
				setState(217); aerationRequest();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WaterTemparatureContext extends ParserRuleContext {
		public WaterTemparatureContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_waterTemparature; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterWaterTemparature(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitWaterTemparature(this);
		}
	}

	public final WaterTemparatureContext waterTemparature() throws RecognitionException {
		WaterTemparatureContext _localctx = new WaterTemparatureContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_waterTemparature);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(220);
			_la = _input.LA(1);
			if ( !(_la==9 || _la==13) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DHContext extends ParserRuleContext {
		public DHContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dH; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterDH(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitDH(this);
		}
	}

	public final DHContext dH() throws RecognitionException {
		DHContext _localctx = new DHContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_dH);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(222);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 38) | (1L << 55) | (1L << 61))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PHContext extends ParserRuleContext {
		public PHContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pH; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterPH(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitPH(this);
		}
	}

	public final PHContext pH() throws RecognitionException {
		PHContext _localctx = new PHContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_pH);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(224);
			_la = _input.LA(1);
			if ( !(_la==20 || _la==28) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WaterRequestContext extends ParserRuleContext {
		public WaterTemparatureContext waterTemparature() {
			return getRuleContext(WaterTemparatureContext.class,0);
		}
		public DHContext dH() {
			return getRuleContext(DHContext.class,0);
		}
		public PHContext pH() {
			return getRuleContext(PHContext.class,0);
		}
		public WaterRequestContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_waterRequest; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterWaterRequest(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitWaterRequest(this);
		}
	}

	public final WaterRequestContext waterRequest() throws RecognitionException {
		WaterRequestContext _localctx = new WaterRequestContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_waterRequest);
		try {
			setState(229);
			switch (_input.LA(1)) {
			case 9:
			case 13:
				enterOuterAlt(_localctx, 1);
				{
				setState(226); waterTemparature();
				}
				break;
			case 38:
			case 55:
			case 61:
				enterOuterAlt(_localctx, 2);
				{
				setState(227); dH();
				}
				break;
			case 20:
			case 28:
				enterOuterAlt(_localctx, 3);
				{
				setState(228); pH();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FishSetContext extends ParserRuleContext {
		public FishSetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fishSet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterFishSet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitFishSet(this);
		}
	}

	public final FishSetContext fishSet() throws RecognitionException {
		FishSetContext _localctx = new FishSetContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_fishSet);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(231);
			_la = _input.LA(1);
			if ( !(_la==17 || _la==75) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FishClassContext extends ParserRuleContext {
		public FishClassContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fishClass; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterFishClass(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitFishClass(this);
		}
	}

	public final FishClassContext fishClass() throws RecognitionException {
		FishClassContext _localctx = new FishClassContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_fishClass);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(233);
			_la = _input.LA(1);
			if ( !(_la==30 || _la==79) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class KindOfFishContext extends ParserRuleContext {
		public KindOfFishContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_kindOfFish; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterKindOfFish(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitKindOfFish(this);
		}
	}

	public final KindOfFishContext kindOfFish() throws RecognitionException {
		KindOfFishContext _localctx = new KindOfFishContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_kindOfFish);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(235);
			_la = _input.LA(1);
			if ( !(_la==68 || _la==84) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubspeciesContext extends ParserRuleContext {
		public FishSetContext fishSet() {
			return getRuleContext(FishSetContext.class,0);
		}
		public KindOfFishContext kindOfFish() {
			return getRuleContext(KindOfFishContext.class,0);
		}
		public FishClassContext fishClass() {
			return getRuleContext(FishClassContext.class,0);
		}
		public SubspeciesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subspecies; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterSubspecies(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitSubspecies(this);
		}
	}

	public final SubspeciesContext subspecies() throws RecognitionException {
		SubspeciesContext _localctx = new SubspeciesContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_subspecies);
		try {
			setState(240);
			switch (_input.LA(1)) {
			case 17:
			case 75:
				enterOuterAlt(_localctx, 1);
				{
				setState(237); fishSet();
				}
				break;
			case 30:
			case 79:
				enterOuterAlt(_localctx, 2);
				{
				setState(238); fishClass();
				}
				break;
			case 68:
			case 84:
				enterOuterAlt(_localctx, 3);
				{
				setState(239); kindOfFish();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LongFishContext extends ParserRuleContext {
		public LongFishContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_longFish; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterLongFish(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitLongFish(this);
		}
	}

	public final LongFishContext longFish() throws RecognitionException {
		LongFishContext _localctx = new LongFishContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_longFish);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(242);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 7) | (1L << 8) | (1L << 27) | (1L << 42) | (1L << 43) | (1L << 50) | (1L << 51))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (73 - 73)) | (1L << (80 - 73)) | (1L << (83 - 73)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OrginationContext extends ParserRuleContext {
		public OrginationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_orgination; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterOrgination(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitOrgination(this);
		}
	}

	public final OrginationContext orgination() throws RecognitionException {
		OrginationContext _localctx = new OrginationContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_orgination);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(244); match(23);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DistributionContext extends ParserRuleContext {
		public DistributionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_distribution; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterDistribution(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitDistribution(this);
		}
	}

	public final DistributionContext distribution() throws RecognitionException {
		DistributionContext _localctx = new DistributionContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_distribution);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(246); match(16);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WaterFieldContext extends ParserRuleContext {
		public WaterFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_waterField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterWaterField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitWaterField(this);
		}
	}

	public final WaterFieldContext waterField() throws RecognitionException {
		WaterFieldContext _localctx = new WaterFieldContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_waterField);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(248); match(1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DesignAquariumContext extends ParserRuleContext {
		public DesignAquariumContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_designAquarium; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterDesignAquarium(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitDesignAquarium(this);
		}
	}

	public final DesignAquariumContext designAquarium() throws RecognitionException {
		DesignAquariumContext _localctx = new DesignAquariumContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_designAquarium);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(250);
			_la = _input.LA(1);
			if ( !(((((_la - 41)) & ~0x3f) == 0 && ((1L << (_la - 41)) & ((1L << (41 - 41)) | (1L << (47 - 41)) | (1L << (82 - 41)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class KindOfFoodContext extends ParserRuleContext {
		public KindOfFoodContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_kindOfFood; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterKindOfFood(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitKindOfFood(this);
		}
	}

	public final KindOfFoodContext kindOfFood() throws RecognitionException {
		KindOfFoodContext _localctx = new KindOfFoodContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_kindOfFood);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(252);
			_la = _input.LA(1);
			if ( !(_la==54 || _la==65) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CaringContext extends ParserRuleContext {
		public CaringContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_caring; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterCaring(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitCaring(this);
		}
	}

	public final CaringContext caring() throws RecognitionException {
		CaringContext _localctx = new CaringContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_caring);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(254);
			_la = _input.LA(1);
			if ( !(_la==15 || _la==37) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GeneralInfoContext extends ParserRuleContext {
		public GeneralInfoContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_generalInfo; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterGeneralInfo(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitGeneralInfo(this);
		}
	}

	public final GeneralInfoContext generalInfo() throws RecognitionException {
		GeneralInfoContext _localctx = new GeneralInfoContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_generalInfo);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(256);
			_la = _input.LA(1);
			if ( !(_la==59 || _la==64) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BiologyContext extends ParserRuleContext {
		public BiologyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_biology; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterBiology(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitBiology(this);
		}
	}

	public final BiologyContext biology() throws RecognitionException {
		BiologyContext _localctx = new BiologyContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_biology);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(258);
			_la = _input.LA(1);
			if ( !(_la==4 || _la==62) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CultureTechContext extends ParserRuleContext {
		public CultureTechContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cultureTech; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterCultureTech(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitCultureTech(this);
		}
	}

	public final CultureTechContext cultureTech() throws RecognitionException {
		CultureTechContext _localctx = new CultureTechContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_cultureTech);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(260);
			_la = _input.LA(1);
			if ( !(((((_la - 46)) & ~0x3f) == 0 && ((1L << (_la - 46)) & ((1L << (46 - 46)) | (1L << (76 - 46)) | (1L << (86 - 46)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RepronductionContext extends ParserRuleContext {
		public RepronductionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_repronduction; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterRepronduction(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitRepronduction(this);
		}
	}

	public final RepronductionContext repronduction() throws RecognitionException {
		RepronductionContext _localctx = new RepronductionContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_repronduction);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(262);
			_la = _input.LA(1);
			if ( !(_la==32 || _la==36) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ClassificationContext extends ParserRuleContext {
		public ClassificationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classification; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterClassification(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitClassification(this);
		}
	}

	public final ClassificationContext classification() throws RecognitionException {
		ClassificationContext _localctx = new ClassificationContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_classification);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(264);
			_la = _input.LA(1);
			if ( !(_la==35 || _la==69) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VerbPharseStartQues1Context extends ParserRuleContext {
		public VerbPharseStartQues1Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_verbPharseStartQues1; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVerbPharseStartQues1(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVerbPharseStartQues1(this);
		}
	}

	public final VerbPharseStartQues1Context verbPharseStartQues1() throws RecognitionException {
		VerbPharseStartQues1Context _localctx = new VerbPharseStartQues1Context(_ctx, getState());
		enterRule(_localctx, 64, RULE_verbPharseStartQues1);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(266);
			_la = _input.LA(1);
			if ( !(_la==24 || _la==49) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VerbPharseStartQues2Context extends ParserRuleContext {
		public VerbPharseStartQues2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_verbPharseStartQues2; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVerbPharseStartQues2(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVerbPharseStartQues2(this);
		}
	}

	public final VerbPharseStartQues2Context verbPharseStartQues2() throws RecognitionException {
		VerbPharseStartQues2Context _localctx = new VerbPharseStartQues2Context(_ctx, getState());
		enterRule(_localctx, 66, RULE_verbPharseStartQues2);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(268);
			_la = _input.LA(1);
			if ( !(_la==6 || _la==45) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VerbPharseStartQues3Context extends ParserRuleContext {
		public VerbPharseStartQues3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_verbPharseStartQues3; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVerbPharseStartQues3(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVerbPharseStartQues3(this);
		}
	}

	public final VerbPharseStartQues3Context verbPharseStartQues3() throws RecognitionException {
		VerbPharseStartQues3Context _localctx = new VerbPharseStartQues3Context(_ctx, getState());
		enterRule(_localctx, 68, RULE_verbPharseStartQues3);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(270);
			_la = _input.LA(1);
			if ( !(_la==19 || _la==22) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class INContext extends ParserRuleContext {
		public INContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_iN; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterIN(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitIN(this);
		}
	}

	public final INContext iN() throws RecognitionException {
		INContext _localctx = new INContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_iN);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(272); match(44);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InInContext extends ParserRuleContext {
		public InInContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inIn; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterInIn(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitInIn(this);
		}
	}

	public final InInContext inIn() throws RecognitionException {
		InInContext _localctx = new InInContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_inIn);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(274); match(18);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InCanContext extends ParserRuleContext {
		public InCanContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inCan; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterInCan(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitInCan(this);
		}
	}

	public final InCanContext inCan() throws RecognitionException {
		InCanContext _localctx = new InCanContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_inCan);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(276); match(72);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InForContext extends ParserRuleContext {
		public InForContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inFor; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterInFor(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitInFor(this);
		}
	}

	public final InForContext inFor() throws RecognitionException {
		InForContext _localctx = new InForContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_inFor);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(278); match(52);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NnFishContext extends ParserRuleContext {
		public NnFishContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nnFish; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterNnFish(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitNnFish(this);
		}
	}

	public final NnFishContext nnFish() throws RecognitionException {
		NnFishContext _localctx = new NnFishContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_nnFish);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(280); match(78);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NnAquariumContext extends ParserRuleContext {
		public NnAquariumContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nnAquarium; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterNnAquarium(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitNnAquarium(this);
		}
	}

	public final NnAquariumContext nnAquarium() throws RecognitionException {
		NnAquariumContext _localctx = new NnAquariumContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_nnAquarium);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(282); match(82);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NnWaterContext extends ParserRuleContext {
		public NnWaterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nnWater; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterNnWater(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitNnWater(this);
		}
	}

	public final NnWaterContext nnWater() throws RecognitionException {
		NnWaterContext _localctx = new NnWaterContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_nnWater);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(284); match(11);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VbBeContext extends ParserRuleContext {
		public VbBeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vbBe; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVbBe(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVbBe(this);
		}
	}

	public final VbBeContext vbBe() throws RecognitionException {
		VbBeContext _localctx = new VbBeContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_vbBe);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(286); match(40);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VbHaveContext extends ParserRuleContext {
		public VbHaveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vbHave; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVbHave(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVbHave(this);
		}
	}

	public final VbHaveContext vbHave() throws RecognitionException {
		VbHaveContext _localctx = new VbHaveContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_vbHave);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(288); match(66);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VbOfContext extends ParserRuleContext {
		public VbOfContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vbOf; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVbOf(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVbOf(this);
		}
	}

	public final VbOfContext vbOf() throws RecognitionException {
		VbOfContext _localctx = new VbOfContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_vbOf);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(290); match(12);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VbLiveContext extends ParserRuleContext {
		public VbLiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vbLive; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVbLive(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVbLive(this);
		}
	}

	public final VbLiveContext vbLive() throws RecognitionException {
		VbLiveContext _localctx = new VbLiveContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_vbLive);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(292); match(58);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VbFeedContext extends ParserRuleContext {
		public VbFeedContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vbFeed; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVbFeed(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVbFeed(this);
		}
	}

	public final VbFeedContext vbFeed() throws RecognitionException {
		VbFeedContext _localctx = new VbFeedContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_vbFeed);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(294); match(46);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VbGetContext extends ParserRuleContext {
		public VbGetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vbGet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVbGet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVbGet(this);
		}
	}

	public final VbGetContext vbGet() throws RecognitionException {
		VbGetContext _localctx = new VbGetContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_vbGet);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(296); match(57);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VbEatContext extends ParserRuleContext {
		public VbEatContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vbEat; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVbEat(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVbEat(this);
		}
	}

	public final VbEatContext vbEat() throws RecognitionException {
		VbEatContext _localctx = new VbEatContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_vbEat);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(298); match(67);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VbNeedContext extends ParserRuleContext {
		public VbNeedContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vbNeed; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterVbNeed(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitVbNeed(this);
		}
	}

	public final VbNeedContext vbNeed() throws RecognitionException {
		VbNeedContext _localctx = new VbNeedContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_vbNeed);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(300); match(85);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AdvToContext extends ParserRuleContext {
		public AdvToContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_advTo; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterAdvTo(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitAdvTo(this);
		}
	}

	public final AdvToContext advTo() throws RecognitionException {
		AdvToContext _localctx = new AdvToContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_advTo);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(302); match(74);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DtTheContext extends ParserRuleContext {
		public DtTheContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dtThe; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterDtThe(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitDtThe(this);
		}
	}

	public final DtTheContext dtThe() throws RecognitionException {
		DtTheContext _localctx = new DtTheContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_dtThe);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(304); match(3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Where01Context extends ParserRuleContext {
		public Where01Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_where01; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterWhere01(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitWhere01(this);
		}
	}

	public final Where01Context where01() throws RecognitionException {
		Where01Context _localctx = new Where01Context(_ctx, getState());
		enterRule(_localctx, 104, RULE_where01);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(306); match(31);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Where02Context extends ParserRuleContext {
		public Where02Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_where02; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterWhere02(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitWhere02(this);
		}
	}

	public final Where02Context where02() throws RecognitionException {
		Where02Context _localctx = new Where02Context(_ctx, getState());
		enterRule(_localctx, 106, RULE_where02);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(308);
			_la = _input.LA(1);
			if ( !(_la==5 || _la==29) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expletive01Context extends ParserRuleContext {
		public Expletive01Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expletive01; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterExpletive01(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitExpletive01(this);
		}
	}

	public final Expletive01Context expletive01() throws RecognitionException {
		Expletive01Context _localctx = new Expletive01Context(_ctx, getState());
		enterRule(_localctx, 108, RULE_expletive01);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(310); match(40);
			setState(312);
			_la = _input.LA(1);
			if (_la==34) {
				{
				setState(311); match(34);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expletive02Context extends ParserRuleContext {
		public Expletive02Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expletive02; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterExpletive02(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitExpletive02(this);
		}
	}

	public final Expletive02Context expletive02() throws RecognitionException {
		Expletive02Context _localctx = new Expletive02Context(_ctx, getState());
		enterRule(_localctx, 110, RULE_expletive02);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(314); match(21);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expletive03Context extends ParserRuleContext {
		public Expletive03Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expletive03; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterExpletive03(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitExpletive03(this);
		}
	}

	public final Expletive03Context expletive03() throws RecognitionException {
		Expletive03Context _localctx = new Expletive03Context(_ctx, getState());
		enterRule(_localctx, 112, RULE_expletive03);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(316);
			_la = _input.LA(1);
			if ( !(_la==34 || _la==60) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expletive04Context extends ParserRuleContext {
		public Expletive04Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expletive04; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterExpletive04(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitExpletive04(this);
		}
	}

	public final Expletive04Context expletive04() throws RecognitionException {
		Expletive04Context _localctx = new Expletive04Context(_ctx, getState());
		enterRule(_localctx, 114, RULE_expletive04);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(318); match(56);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expletive05Context extends ParserRuleContext {
		public Expletive05Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expletive05; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterExpletive05(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitExpletive05(this);
		}
	}

	public final Expletive05Context expletive05() throws RecognitionException {
		Expletive05Context _localctx = new Expletive05Context(_ctx, getState());
		enterRule(_localctx, 116, RULE_expletive05);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(320); match(14);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expletive06Context extends ParserRuleContext {
		public Expletive06Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expletive06; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterExpletive06(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitExpletive06(this);
		}
	}

	public final Expletive06Context expletive06() throws RecognitionException {
		Expletive06Context _localctx = new Expletive06Context(_ctx, getState());
		enterRule(_localctx, 118, RULE_expletive06);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(323);
			_la = _input.LA(1);
			if (_la==40) {
				{
				setState(322); match(40);
				}
			}

			setState(325); match(81);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expletive07Context extends ParserRuleContext {
		public Expletive07Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expletive07; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterExpletive07(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitExpletive07(this);
		}
	}

	public final Expletive07Context expletive07() throws RecognitionException {
		Expletive07Context _localctx = new Expletive07Context(_ctx, getState());
		enterRule(_localctx, 120, RULE_expletive07);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(327); match(57);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EndQues01Context extends ParserRuleContext {
		public Expletive01Context expletive01() {
			return getRuleContext(Expletive01Context.class,0);
		}
		public EndQues01Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_endQues01; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterEndQues01(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitEndQues01(this);
		}
	}

	public final EndQues01Context endQues01() throws RecognitionException {
		EndQues01Context _localctx = new EndQues01Context(_ctx, getState());
		enterRule(_localctx, 122, RULE_endQues01);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(329); expletive01();
			setState(330); match(53);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EndQues02Context extends ParserRuleContext {
		public EndQues02Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_endQues02; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterEndQues02(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitEndQues02(this);
		}
	}

	public final EndQues02Context endQues02() throws RecognitionException {
		EndQues02Context _localctx = new EndQues02Context(_ctx, getState());
		enterRule(_localctx, 124, RULE_endQues02);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(332); match(53);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EndQues03Context extends ParserRuleContext {
		public Expletive02Context expletive02() {
			return getRuleContext(Expletive02Context.class,0);
		}
		public EndQues03Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_endQues03; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterEndQues03(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitEndQues03(this);
		}
	}

	public final EndQues03Context endQues03() throws RecognitionException {
		EndQues03Context _localctx = new EndQues03Context(_ctx, getState());
		enterRule(_localctx, 126, RULE_endQues03);
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(334); expletive02();
			}
			setState(335); match(53);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EndQues04Context extends ParserRuleContext {
		public Expletive04Context expletive04() {
			return getRuleContext(Expletive04Context.class,0);
		}
		public EndQues04Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_endQues04; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterEndQues04(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitEndQues04(this);
		}
	}

	public final EndQues04Context endQues04() throws RecognitionException {
		EndQues04Context _localctx = new EndQues04Context(_ctx, getState());
		enterRule(_localctx, 128, RULE_endQues04);
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(337); expletive04();
			}
			setState(338); match(53);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EndQues05Context extends ParserRuleContext {
		public Expletive05Context expletive05() {
			return getRuleContext(Expletive05Context.class,0);
		}
		public EndQues05Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_endQues05; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterEndQues05(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitEndQues05(this);
		}
	}

	public final EndQues05Context endQues05() throws RecognitionException {
		EndQues05Context _localctx = new EndQues05Context(_ctx, getState());
		enterRule(_localctx, 130, RULE_endQues05);
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(340); expletive05();
			}
			setState(341); match(53);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EndQues06Context extends ParserRuleContext {
		public Expletive03Context expletive03() {
			return getRuleContext(Expletive03Context.class,0);
		}
		public EndQues06Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_endQues06; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterEndQues06(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitEndQues06(this);
		}
	}

	public final EndQues06Context endQues06() throws RecognitionException {
		EndQues06Context _localctx = new EndQues06Context(_ctx, getState());
		enterRule(_localctx, 132, RULE_endQues06);
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(343); expletive03();
			}
			setState(344); match(53);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EndQues07Context extends ParserRuleContext {
		public Expletive06Context expletive06() {
			return getRuleContext(Expletive06Context.class,0);
		}
		public EndQues07Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_endQues07; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterEndQues07(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitEndQues07(this);
		}
	}

	public final EndQues07Context endQues07() throws RecognitionException {
		EndQues07Context _localctx = new EndQues07Context(_ctx, getState());
		enterRule(_localctx, 134, RULE_endQues07);
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(346); expletive06();
			}
			setState(347); match(53);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EndQues08Context extends ParserRuleContext {
		public Expletive07Context expletive07() {
			return getRuleContext(Expletive07Context.class,0);
		}
		public EndQues08Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_endQues08; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterEndQues08(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitEndQues08(this);
		}
	}

	public final EndQues08Context endQues08() throws RecognitionException {
		EndQues08Context _localctx = new EndQues08Context(_ctx, getState());
		enterRule(_localctx, 136, RULE_endQues08);
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(349); expletive07();
			}
			setState(350); match(53);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NameFishContext extends ParserRuleContext {
		public TerminalNode N3(int i) {
			return getToken(quesParser.N3, i);
		}
		public TerminalNode N2(int i) {
			return getToken(quesParser.N2, i);
		}
		public List<TerminalNode> N1() { return getTokens(quesParser.N1); }
		public TerminalNode N1(int i) {
			return getToken(quesParser.N1, i);
		}
		public List<TerminalNode> N2() { return getTokens(quesParser.N2); }
		public List<TerminalNode> N3() { return getTokens(quesParser.N3); }
		public NameFishContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nameFish; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterNameFish(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitNameFish(this);
		}
	}

	public final NameFishContext nameFish() throws RecognitionException {
		NameFishContext _localctx = new NameFishContext(_ctx, getState());
		enterRule(_localctx, 138, RULE_nameFish);
		int _la;
		try {
			setState(362);
			switch (_input.LA(1)) {
			case N1:
			case N2:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(353); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(352);
					_la = _input.LA(1);
					if ( !(_la==N1 || _la==N2) ) {
					_errHandler.recoverInline(this);
					}
					consume();
					}
					}
					setState(355); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==N1 || _la==N2 );
				}
				}
				break;
			case N3:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(358); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(357); match(N3);
					}
					}
					setState(360); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==N3 );
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Info01Context extends ParserRuleContext {
		public SubspeciesContext subspecies() {
			return getRuleContext(SubspeciesContext.class,0);
		}
		public RequestContext request() {
			return getRuleContext(RequestContext.class,0);
		}
		public GeneralInfoContext generalInfo() {
			return getRuleContext(GeneralInfoContext.class,0);
		}
		public BiologyContext biology() {
			return getRuleContext(BiologyContext.class,0);
		}
		public ClassificationContext classification() {
			return getRuleContext(ClassificationContext.class,0);
		}
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public WaterFieldContext waterField() {
			return getRuleContext(WaterFieldContext.class,0);
		}
		public RepronductionContext repronduction() {
			return getRuleContext(RepronductionContext.class,0);
		}
		public KindOfFoodContext kindOfFood() {
			return getRuleContext(KindOfFoodContext.class,0);
		}
		public CultureTechContext cultureTech() {
			return getRuleContext(CultureTechContext.class,0);
		}
		public Info01Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_info01; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterInfo01(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitInfo01(this);
		}
	}

	public final Info01Context info01() throws RecognitionException {
		Info01Context _localctx = new Info01Context(_ctx, getState());
		enterRule(_localctx, 140, RULE_info01);
		try {
			setState(375);
			switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(364); name();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(365); request();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(366); repronduction();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(367); waterField();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(368); generalInfo();
				}
				break;

			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(369); repronduction();
				}
				break;

			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(370); biology();
				}
				break;

			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(371); classification();
				}
				break;

			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(372); cultureTech();
				}
				break;

			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(373); kindOfFood();
				}
				break;

			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(374); subspecies();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Info02Context extends ParserRuleContext {
		public DesignAquariumContext designAquarium() {
			return getRuleContext(DesignAquariumContext.class,0);
		}
		public RepronductionContext repronduction() {
			return getRuleContext(RepronductionContext.class,0);
		}
		public OrginationContext orgination() {
			return getRuleContext(OrginationContext.class,0);
		}
		public Info02Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_info02; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterInfo02(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitInfo02(this);
		}
	}

	public final Info02Context info02() throws RecognitionException {
		Info02Context _localctx = new Info02Context(_ctx, getState());
		enterRule(_localctx, 142, RULE_info02);
		try {
			setState(380);
			switch (_input.LA(1)) {
			case 23:
				enterOuterAlt(_localctx, 1);
				{
				setState(377); orgination();
				}
				break;
			case 41:
			case 47:
			case 82:
				enterOuterAlt(_localctx, 2);
				{
				setState(378); designAquarium();
				}
				break;
			case 32:
			case 36:
				enterOuterAlt(_localctx, 3);
				{
				setState(379); repronduction();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh01Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public Info01Context info01() {
			return getRuleContext(Info01Context.class,0);
		}
		public EndQues01Context endQues01() {
			return getRuleContext(EndQues01Context.class,0);
		}
		public INContext iN() {
			return getRuleContext(INContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VerbPharseStartQues2Context verbPharseStartQues2() {
			return getRuleContext(VerbPharseStartQues2Context.class,0);
		}
		public QuestionWh01Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh01; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh01(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh01(this);
		}
	}

	public final QuestionWh01Context questionWh01() throws RecognitionException {
		QuestionWh01Context _localctx = new QuestionWh01Context(_ctx, getState());
		enterRule(_localctx, 144, RULE_questionWh01);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(384);
			switch (_input.LA(1)) {
			case 24:
			case 49:
				{
				setState(382); verbPharseStartQues1();
				}
				break;
			case 6:
			case 45:
				{
				setState(383); verbPharseStartQues2();
				}
				break;
			case 1:
			case 2:
			case 4:
			case 10:
			case 17:
			case 25:
			case 26:
			case 30:
			case 32:
			case 33:
			case 35:
			case 36:
			case 39:
			case 46:
			case 48:
			case 54:
			case 59:
			case 62:
			case 63:
			case 64:
			case 65:
			case 68:
			case 69:
			case 70:
			case 71:
			case 75:
			case 76:
			case 77:
			case 79:
			case 84:
			case 86:
			case 87:
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(386); info01();
			setState(388);
			_la = _input.LA(1);
			if (_la==44) {
				{
				setState(387); iN();
				}
			}

			setState(390); nnFish();
			setState(391); nameFish();
			setState(392); endQues01();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh02Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public DistributionContext distribution() {
			return getRuleContext(DistributionContext.class,0);
		}
		public Info01Context info01() {
			return getRuleContext(Info01Context.class,0);
		}
		public INContext iN() {
			return getRuleContext(INContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public EndQues02Context endQues02() {
			return getRuleContext(EndQues02Context.class,0);
		}
		public Info02Context info02() {
			return getRuleContext(Info02Context.class,0);
		}
		public VerbPharseStartQues2Context verbPharseStartQues2() {
			return getRuleContext(VerbPharseStartQues2Context.class,0);
		}
		public CaringContext caring() {
			return getRuleContext(CaringContext.class,0);
		}
		public QuestionWh02Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh02; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh02(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh02(this);
		}
	}

	public final QuestionWh02Context questionWh02() throws RecognitionException {
		QuestionWh02Context _localctx = new QuestionWh02Context(_ctx, getState());
		enterRule(_localctx, 146, RULE_questionWh02);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(396);
			switch (_input.LA(1)) {
			case 24:
			case 49:
				{
				setState(394); verbPharseStartQues1();
				}
				break;
			case 6:
			case 45:
				{
				setState(395); verbPharseStartQues2();
				}
				break;
			case 1:
			case 2:
			case 4:
			case 10:
			case 15:
			case 16:
			case 17:
			case 23:
			case 25:
			case 26:
			case 30:
			case 32:
			case 33:
			case 35:
			case 36:
			case 37:
			case 39:
			case 41:
			case 46:
			case 47:
			case 48:
			case 54:
			case 59:
			case 62:
			case 63:
			case 64:
			case 65:
			case 68:
			case 69:
			case 70:
			case 71:
			case 75:
			case 76:
			case 77:
			case 79:
			case 82:
			case 84:
			case 86:
			case 87:
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(402);
			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
			case 1:
				{
				setState(398); info02();
				}
				break;

			case 2:
				{
				setState(399); info01();
				}
				break;

			case 3:
				{
				setState(400); caring();
				}
				break;

			case 4:
				{
				setState(401); distribution();
				}
				break;
			}
			setState(405);
			_la = _input.LA(1);
			if (_la==44) {
				{
				setState(404); iN();
				}
			}

			setState(407); nnFish();
			setState(408); nameFish();
			setState(409); endQues02();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh03Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public VbBeContext vbBe() {
			return getRuleContext(VbBeContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish(int i) {
			return getRuleContext(NnFishContext.class,i);
		}
		public List<NnFishContext> nnFish() {
			return getRuleContexts(NnFishContext.class);
		}
		public EndQues02Context endQues02() {
			return getRuleContext(EndQues02Context.class,0);
		}
		public EndQues06Context endQues06() {
			return getRuleContext(EndQues06Context.class,0);
		}
		public EndQues03Context endQues03() {
			return getRuleContext(EndQues03Context.class,0);
		}
		public EndQues04Context endQues04() {
			return getRuleContext(EndQues04Context.class,0);
		}
		public QuestionWh03Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh03; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh03(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh03(this);
		}
	}

	public final QuestionWh03Context questionWh03() throws RecognitionException {
		QuestionWh03Context _localctx = new QuestionWh03Context(_ctx, getState());
		enterRule(_localctx, 148, RULE_questionWh03);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(412);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(411); verbPharseStartQues1();
				}
			}

			setState(414); nnFish();
			setState(415); nameFish();
			setState(416); vbBe();
			setState(417); nnFish();
			setState(422);
			switch (_input.LA(1)) {
			case 21:
				{
				setState(418); endQues03();
				}
				break;
			case 53:
				{
				setState(419); endQues02();
				}
				break;
			case 56:
				{
				setState(420); endQues04();
				}
				break;
			case 34:
			case 60:
				{
				setState(421); endQues06();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh04Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public Info01Context info01() {
			return getRuleContext(Info01Context.class,0);
		}
		public EndQues01Context endQues01() {
			return getRuleContext(EndQues01Context.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbHaveContext vbHave() {
			return getRuleContext(VbHaveContext.class,0);
		}
		public QuestionWh04Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh04; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh04(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh04(this);
		}
	}

	public final QuestionWh04Context questionWh04() throws RecognitionException {
		QuestionWh04Context _localctx = new QuestionWh04Context(_ctx, getState());
		enterRule(_localctx, 150, RULE_questionWh04);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(425);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(424); verbPharseStartQues1();
				}
			}

			setState(427); nnFish();
			setState(428); nameFish();
			setState(429); vbHave();
			setState(430); info01();
			setState(431); endQues01();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh05Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public VbBeContext vbBe() {
			return getRuleContext(VbBeContext.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbHaveContext vbHave() {
			return getRuleContext(VbHaveContext.class,0);
		}
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public Expletive03Context expletive03() {
			return getRuleContext(Expletive03Context.class,0);
		}
		public EndQues02Context endQues02() {
			return getRuleContext(EndQues02Context.class,0);
		}
		public QuestionWh05Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh05; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh05(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh05(this);
		}
	}

	public final QuestionWh05Context questionWh05() throws RecognitionException {
		QuestionWh05Context _localctx = new QuestionWh05Context(_ctx, getState());
		enterRule(_localctx, 152, RULE_questionWh05);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(434);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(433); verbPharseStartQues1();
				}
			}

			setState(436); nnFish();
			setState(438);
			_la = _input.LA(1);
			if (_la==34 || _la==60) {
				{
				setState(437); expletive03();
				}
			}

			setState(440); vbHave();
			setState(441); name();
			setState(443);
			_la = _input.LA(1);
			if (_la==40) {
				{
				setState(442); vbBe();
				}
			}

			setState(445); nameFish();
			setState(446); endQues02();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh06Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public INContext iN() {
			return getRuleContext(INContext.class,0);
		}
		public VbBeContext vbBe() {
			return getRuleContext(VbBeContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish(int i) {
			return getRuleContext(NnFishContext.class,i);
		}
		public List<NnFishContext> nnFish() {
			return getRuleContexts(NnFishContext.class);
		}
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public EndQues02Context endQues02() {
			return getRuleContext(EndQues02Context.class,0);
		}
		public EndQues06Context endQues06() {
			return getRuleContext(EndQues06Context.class,0);
		}
		public EndQues04Context endQues04() {
			return getRuleContext(EndQues04Context.class,0);
		}
		public QuestionWh06Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh06; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh06(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh06(this);
		}
	}

	public final QuestionWh06Context questionWh06() throws RecognitionException {
		QuestionWh06Context _localctx = new QuestionWh06Context(_ctx, getState());
		enterRule(_localctx, 154, RULE_questionWh06);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(449);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(448); verbPharseStartQues1();
				}
			}

			setState(452);
			_la = _input.LA(1);
			if (_la==78) {
				{
				setState(451); nnFish();
				}
			}

			setState(454); nameFish();
			setState(455); vbBe();
			setState(456); name();
			setState(457); iN();
			setState(458); nnFish();
			setState(462);
			switch (_input.LA(1)) {
			case 53:
				{
				setState(459); endQues02();
				}
				break;
			case 56:
				{
				setState(460); endQues04();
				}
				break;
			case 34:
			case 60:
				{
				setState(461); endQues06();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh07Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public Info01Context info01() {
			return getRuleContext(Info01Context.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbHaveContext vbHave() {
			return getRuleContext(VbHaveContext.class,0);
		}
		public Info02Context info02() {
			return getRuleContext(Info02Context.class,0);
		}
		public EndQues03Context endQues03() {
			return getRuleContext(EndQues03Context.class,0);
		}
		public EndQues05Context endQues05() {
			return getRuleContext(EndQues05Context.class,0);
		}
		public QuestionWh07Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh07; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh07(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh07(this);
		}
	}

	public final QuestionWh07Context questionWh07() throws RecognitionException {
		QuestionWh07Context _localctx = new QuestionWh07Context(_ctx, getState());
		enterRule(_localctx, 156, RULE_questionWh07);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(465);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(464); verbPharseStartQues1();
				}
			}

			setState(467); nnFish();
			setState(468); nameFish();
			setState(469); vbHave();
			setState(472);
			switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
			case 1:
				{
				setState(470); info01();
				}
				break;

			case 2:
				{
				setState(471); info02();
				}
				break;
			}
			setState(476);
			switch (_input.LA(1)) {
			case 14:
				{
				setState(474); endQues05();
				}
				break;
			case 21:
				{
				setState(475); endQues03();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh08Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public VbOfContext vbOf() {
			return getRuleContext(VbOfContext.class,0);
		}
		public SubspeciesContext subspecies() {
			return getRuleContext(SubspeciesContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public EndQues06Context endQues06() {
			return getRuleContext(EndQues06Context.class,0);
		}
		public EndQues04Context endQues04() {
			return getRuleContext(EndQues04Context.class,0);
		}
		public QuestionWh08Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh08; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh08(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh08(this);
		}
	}

	public final QuestionWh08Context questionWh08() throws RecognitionException {
		QuestionWh08Context _localctx = new QuestionWh08Context(_ctx, getState());
		enterRule(_localctx, 158, RULE_questionWh08);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(479);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(478); verbPharseStartQues1();
				}
			}

			setState(481); nnFish();
			setState(482); nameFish();
			setState(483); vbOf();
			setState(484); subspecies();
			setState(487);
			switch (_input.LA(1)) {
			case 56:
				{
				setState(485); endQues04();
				}
				break;
			case 34:
			case 60:
				{
				setState(486); endQues06();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh09Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public Info01Context info01() {
			return getRuleContext(Info01Context.class,0);
		}
		public INContext iN() {
			return getRuleContext(INContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public Info02Context info02() {
			return getRuleContext(Info02Context.class,0);
		}
		public EndQues03Context endQues03() {
			return getRuleContext(EndQues03Context.class,0);
		}
		public VerbPharseStartQues2Context verbPharseStartQues2() {
			return getRuleContext(VerbPharseStartQues2Context.class,0);
		}
		public EndQues05Context endQues05() {
			return getRuleContext(EndQues05Context.class,0);
		}
		public QuestionWh09Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh09; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh09(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh09(this);
		}
	}

	public final QuestionWh09Context questionWh09() throws RecognitionException {
		QuestionWh09Context _localctx = new QuestionWh09Context(_ctx, getState());
		enterRule(_localctx, 160, RULE_questionWh09);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(491);
			switch (_input.LA(1)) {
			case 24:
			case 49:
				{
				setState(489); verbPharseStartQues1();
				}
				break;
			case 6:
			case 45:
				{
				setState(490); verbPharseStartQues2();
				}
				break;
			case 1:
			case 2:
			case 4:
			case 10:
			case 17:
			case 23:
			case 25:
			case 26:
			case 30:
			case 32:
			case 33:
			case 35:
			case 36:
			case 39:
			case 41:
			case 46:
			case 47:
			case 48:
			case 54:
			case 59:
			case 62:
			case 63:
			case 64:
			case 65:
			case 68:
			case 69:
			case 70:
			case 71:
			case 75:
			case 76:
			case 77:
			case 79:
			case 82:
			case 84:
			case 86:
			case 87:
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(495);
			switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
			case 1:
				{
				setState(493); info01();
				}
				break;

			case 2:
				{
				setState(494); info02();
				}
				break;
			}
			setState(498);
			_la = _input.LA(1);
			if (_la==44) {
				{
				setState(497); iN();
				}
			}

			setState(500); nnFish();
			setState(501); nameFish();
			setState(504);
			switch (_input.LA(1)) {
			case 14:
				{
				setState(502); endQues05();
				}
				break;
			case 21:
				{
				setState(503); endQues03();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh10Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbHaveContext vbHave() {
			return getRuleContext(VbHaveContext.class,0);
		}
		public EndQues02Context endQues02() {
			return getRuleContext(EndQues02Context.class,0);
		}
		public WaterFieldContext waterField() {
			return getRuleContext(WaterFieldContext.class,0);
		}
		public Where01Context where01() {
			return getRuleContext(Where01Context.class,0);
		}
		public OrginationContext orgination() {
			return getRuleContext(OrginationContext.class,0);
		}
		public QuestionWh10Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh10; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh10(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh10(this);
		}
	}

	public final QuestionWh10Context questionWh10() throws RecognitionException {
		QuestionWh10Context _localctx = new QuestionWh10Context(_ctx, getState());
		enterRule(_localctx, 162, RULE_questionWh10);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(507);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(506); verbPharseStartQues1();
				}
			}

			setState(509); nnFish();
			setState(510); nameFish();
			setState(511); vbHave();
			setState(514);
			switch (_input.LA(1)) {
			case 23:
				{
				setState(512); orgination();
				}
				break;
			case 1:
				{
				setState(513); waterField();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(516); where01();
			setState(517); endQues02();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh11Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public DistributionContext distribution() {
			return getRuleContext(DistributionContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public Where02Context where02() {
			return getRuleContext(Where02Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbHaveContext vbHave() {
			return getRuleContext(VbHaveContext.class,0);
		}
		public EndQues02Context endQues02() {
			return getRuleContext(EndQues02Context.class,0);
		}
		public OrginationContext orgination() {
			return getRuleContext(OrginationContext.class,0);
		}
		public QuestionWh11Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh11; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh11(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh11(this);
		}
	}

	public final QuestionWh11Context questionWh11() throws RecognitionException {
		QuestionWh11Context _localctx = new QuestionWh11Context(_ctx, getState());
		enterRule(_localctx, 164, RULE_questionWh11);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(520);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(519); verbPharseStartQues1();
				}
			}

			setState(522); nnFish();
			setState(523); nameFish();
			setState(524); vbHave();
			setState(527);
			switch (_input.LA(1)) {
			case 23:
				{
				setState(525); orgination();
				}
				break;
			case 16:
				{
				setState(526); distribution();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(529); where02();
			setState(530); endQues02();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh12Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public LongFishContext longFish() {
			return getRuleContext(LongFishContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbHaveContext vbHave() {
			return getRuleContext(VbHaveContext.class,0);
		}
		public WaterRequestContext waterRequest() {
			return getRuleContext(WaterRequestContext.class,0);
		}
		public EndQues07Context endQues07() {
			return getRuleContext(EndQues07Context.class,0);
		}
		public QuestionWh12Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh12; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh12(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh12(this);
		}
	}

	public final QuestionWh12Context questionWh12() throws RecognitionException {
		QuestionWh12Context _localctx = new QuestionWh12Context(_ctx, getState());
		enterRule(_localctx, 166, RULE_questionWh12);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(533);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(532); verbPharseStartQues1();
				}
			}

			setState(535); nnFish();
			setState(536); nameFish();
			setState(537); vbHave();
			setState(540);
			switch (_input.LA(1)) {
			case 9:
			case 13:
			case 20:
			case 28:
			case 38:
			case 55:
			case 61:
				{
				setState(538); waterRequest();
				}
				break;
			case 7:
			case 8:
			case 27:
			case 42:
			case 43:
			case 50:
			case 51:
			case 73:
			case 80:
			case 83:
				{
				setState(539); longFish();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(542); endQues07();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh13Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public VbLiveContext vbLive() {
			return getRuleContext(VbLiveContext.class,0);
		}
		public InInContext inIn() {
			return getRuleContext(InInContext.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public WaterRequestContext waterRequest() {
			return getRuleContext(WaterRequestContext.class,0);
		}
		public EndQues07Context endQues07() {
			return getRuleContext(EndQues07Context.class,0);
		}
		public QuestionWh13Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh13; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh13(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh13(this);
		}
	}

	public final QuestionWh13Context questionWh13() throws RecognitionException {
		QuestionWh13Context _localctx = new QuestionWh13Context(_ctx, getState());
		enterRule(_localctx, 168, RULE_questionWh13);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(545);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(544); verbPharseStartQues1();
				}
			}

			setState(547); nnFish();
			setState(548); nameFish();
			setState(549); vbLive();
			setState(550); inIn();
			setState(551); waterRequest();
			setState(552); endQues07();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh14Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public AdvToContext advTo() {
			return getRuleContext(AdvToContext.class,0);
		}
		public WaterRequestContext waterRequest() {
			return getRuleContext(WaterRequestContext.class,0);
		}
		public VbFeedContext vbFeed() {
			return getRuleContext(VbFeedContext.class,0);
		}
		public EndQues07Context endQues07() {
			return getRuleContext(EndQues07Context.class,0);
		}
		public QuestionWh14Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh14; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh14(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh14(this);
		}
	}

	public final QuestionWh14Context questionWh14() throws RecognitionException {
		QuestionWh14Context _localctx = new QuestionWh14Context(_ctx, getState());
		enterRule(_localctx, 170, RULE_questionWh14);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(555);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(554); verbPharseStartQues1();
				}
			}

			setState(557); waterRequest();
			setState(559);
			_la = _input.LA(1);
			if (_la==74) {
				{
				setState(558); advTo();
				}
			}

			setState(561); vbFeed();
			setState(562); nnFish();
			setState(563); nameFish();
			setState(564); endQues07();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh15Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public VbLiveContext vbLive() {
			return getRuleContext(VbLiveContext.class,0);
		}
		public InInContext inIn() {
			return getRuleContext(InInContext.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbHaveContext vbHave() {
			return getRuleContext(VbHaveContext.class,0);
		}
		public WaterRequestContext waterRequest() {
			return getRuleContext(WaterRequestContext.class,0);
		}
		public EndQues07Context endQues07() {
			return getRuleContext(EndQues07Context.class,0);
		}
		public NnWaterContext nnWater() {
			return getRuleContext(NnWaterContext.class,0);
		}
		public QuestionWh15Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh15; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh15(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh15(this);
		}
	}

	public final QuestionWh15Context questionWh15() throws RecognitionException {
		QuestionWh15Context _localctx = new QuestionWh15Context(_ctx, getState());
		enterRule(_localctx, 172, RULE_questionWh15);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(567);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(566); verbPharseStartQues1();
				}
			}

			setState(569); nnFish();
			setState(570); nameFish();
			setState(571); vbLive();
			setState(572); inIn();
			setState(573); nnWater();
			setState(574); vbHave();
			setState(575); waterRequest();
			setState(576); endQues07();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh16Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public RequestContext request() {
			return getRuleContext(RequestContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public DesignAquariumContext designAquarium() {
			return getRuleContext(DesignAquariumContext.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbGetContext vbGet() {
			return getRuleContext(VbGetContext.class,0);
		}
		public EndQues03Context endQues03() {
			return getRuleContext(EndQues03Context.class,0);
		}
		public CaringContext caring() {
			return getRuleContext(CaringContext.class,0);
		}
		public CultureTechContext cultureTech() {
			return getRuleContext(CultureTechContext.class,0);
		}
		public EndQues05Context endQues05() {
			return getRuleContext(EndQues05Context.class,0);
		}
		public QuestionWh16Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh16; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh16(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh16(this);
		}
	}

	public final QuestionWh16Context questionWh16() throws RecognitionException {
		QuestionWh16Context _localctx = new QuestionWh16Context(_ctx, getState());
		enterRule(_localctx, 174, RULE_questionWh16);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(579);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(578); verbPharseStartQues1();
				}
			}

			setState(581); nnFish();
			setState(582); nameFish();
			setState(583); vbGet();
			setState(588);
			switch (_input.LA(1)) {
			case 15:
			case 37:
				{
				setState(584); caring();
				}
				break;
			case 41:
			case 47:
			case 82:
				{
				setState(585); designAquarium();
				}
				break;
			case 46:
			case 76:
			case 86:
				{
				setState(586); cultureTech();
				}
				break;
			case 25:
			case 33:
			case 48:
			case 71:
				{
				setState(587); request();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(592);
			switch (_input.LA(1)) {
			case 14:
				{
				setState(590); endQues05();
				}
				break;
			case 21:
				{
				setState(591); endQues03();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh17Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public INContext iN() {
			return getRuleContext(INContext.class,0);
		}
		public RequestContext request() {
			return getRuleContext(RequestContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public DesignAquariumContext designAquarium() {
			return getRuleContext(DesignAquariumContext.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbFeedContext vbFeed() {
			return getRuleContext(VbFeedContext.class,0);
		}
		public VbHaveContext vbHave() {
			return getRuleContext(VbHaveContext.class,0);
		}
		public WaterRequestContext waterRequest() {
			return getRuleContext(WaterRequestContext.class,0);
		}
		public NnAquariumContext nnAquarium() {
			return getRuleContext(NnAquariumContext.class,0);
		}
		public EndQues03Context endQues03() {
			return getRuleContext(EndQues03Context.class,0);
		}
		public EndQues05Context endQues05() {
			return getRuleContext(EndQues05Context.class,0);
		}
		public QuestionWh17Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh17; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh17(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh17(this);
		}
	}

	public final QuestionWh17Context questionWh17() throws RecognitionException {
		QuestionWh17Context _localctx = new QuestionWh17Context(_ctx, getState());
		enterRule(_localctx, 176, RULE_questionWh17);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(595);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(594); verbPharseStartQues1();
				}
			}

			setState(597); nnAquarium();
			setState(598); vbFeed();
			setState(600);
			_la = _input.LA(1);
			if (_la==44) {
				{
				setState(599); iN();
				}
			}

			setState(602); nnFish();
			setState(603); nameFish();
			setState(604); vbHave();
			setState(608);
			switch (_input.LA(1)) {
			case 41:
			case 47:
			case 82:
				{
				setState(605); designAquarium();
				}
				break;
			case 25:
			case 33:
			case 48:
			case 71:
				{
				setState(606); request();
				}
				break;
			case 9:
			case 13:
			case 20:
			case 28:
			case 38:
			case 55:
			case 61:
				{
				setState(607); waterRequest();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(612);
			switch (_input.LA(1)) {
			case 14:
				{
				setState(610); endQues05();
				}
				break;
			case 21:
				{
				setState(611); endQues03();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh18Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public DtTheContext dtThe() {
			return getRuleContext(DtTheContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public InCanContext inCan() {
			return getRuleContext(InCanContext.class,0);
		}
		public InForContext inFor() {
			return getRuleContext(InForContext.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public EndQues08Context endQues08() {
			return getRuleContext(EndQues08Context.class,0);
		}
		public Expletive03Context expletive03() {
			return getRuleContext(Expletive03Context.class,0);
		}
		public EndQues02Context endQues02() {
			return getRuleContext(EndQues02Context.class,0);
		}
		public VbEatContext vbEat() {
			return getRuleContext(VbEatContext.class,0);
		}
		public KindOfFoodContext kindOfFood() {
			return getRuleContext(KindOfFoodContext.class,0);
		}
		public VerbPharseStartQues2Context verbPharseStartQues2() {
			return getRuleContext(VerbPharseStartQues2Context.class,0);
		}
		public QuestionWh18Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh18; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh18(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh18(this);
		}
	}

	public final QuestionWh18Context questionWh18() throws RecognitionException {
		QuestionWh18Context _localctx = new QuestionWh18Context(_ctx, getState());
		enterRule(_localctx, 178, RULE_questionWh18);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(616);
			switch (_input.LA(1)) {
			case 24:
			case 49:
				{
				setState(614); verbPharseStartQues1();
				}
				break;
			case 6:
			case 45:
				{
				setState(615); verbPharseStartQues2();
				}
				break;
			case 3:
			case 54:
			case 65:
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(619);
			_la = _input.LA(1);
			if (_la==3) {
				{
				setState(618); dtThe();
				}
			}

			setState(621); kindOfFood();
			setState(623);
			_la = _input.LA(1);
			if (_la==34 || _la==60) {
				{
				setState(622); expletive03();
				}
			}

			setState(626);
			_la = _input.LA(1);
			if (_la==72) {
				{
				setState(625); inCan();
				}
			}

			setState(628); inFor();
			setState(629); nnFish();
			setState(630); nameFish();
			setState(631); vbEat();
			setState(634);
			switch (_input.LA(1)) {
			case 53:
				{
				setState(632); endQues02();
				}
				break;
			case 57:
				{
				setState(633); endQues08();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh19Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public VerbPharseStartQues1Context verbPharseStartQues1() {
			return getRuleContext(VerbPharseStartQues1Context.class,0);
		}
		public DesignAquariumContext designAquarium() {
			return getRuleContext(DesignAquariumContext.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public VbNeedContext vbNeed() {
			return getRuleContext(VbNeedContext.class,0);
		}
		public EndQues03Context endQues03() {
			return getRuleContext(EndQues03Context.class,0);
		}
		public KindOfFoodContext kindOfFood() {
			return getRuleContext(KindOfFoodContext.class,0);
		}
		public Expletive07Context expletive07() {
			return getRuleContext(Expletive07Context.class,0);
		}
		public CaringContext caring() {
			return getRuleContext(CaringContext.class,0);
		}
		public CultureTechContext cultureTech() {
			return getRuleContext(CultureTechContext.class,0);
		}
		public EndQues05Context endQues05() {
			return getRuleContext(EndQues05Context.class,0);
		}
		public QuestionWh19Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh19; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh19(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh19(this);
		}
	}

	public final QuestionWh19Context questionWh19() throws RecognitionException {
		QuestionWh19Context _localctx = new QuestionWh19Context(_ctx, getState());
		enterRule(_localctx, 180, RULE_questionWh19);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(637);
			_la = _input.LA(1);
			if (_la==24 || _la==49) {
				{
				setState(636); verbPharseStartQues1();
				}
			}

			setState(639); nnFish();
			setState(640); nameFish();
			setState(642);
			_la = _input.LA(1);
			if (_la==85) {
				{
				setState(641); vbNeed();
				}
			}

			setState(645);
			_la = _input.LA(1);
			if (_la==57) {
				{
				setState(644); expletive07();
				}
			}

			setState(651);
			switch (_input.LA(1)) {
			case 15:
			case 37:
				{
				setState(647); caring();
				}
				break;
			case 46:
			case 76:
			case 86:
				{
				setState(648); cultureTech();
				}
				break;
			case 41:
			case 47:
			case 82:
				{
				setState(649); designAquarium();
				}
				break;
			case 54:
			case 65:
				{
				setState(650); kindOfFood();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(655);
			switch (_input.LA(1)) {
			case 14:
				{
				setState(653); endQues05();
				}
				break;
			case 21:
				{
				setState(654); endQues03();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionWh20Context extends ParserRuleContext {
		public NameFishContext nameFish() {
			return getRuleContext(NameFishContext.class,0);
		}
		public VerbPharseStartQues3Context verbPharseStartQues3() {
			return getRuleContext(VerbPharseStartQues3Context.class,0);
		}
		public DesignAquariumContext designAquarium() {
			return getRuleContext(DesignAquariumContext.class,0);
		}
		public NnFishContext nnFish() {
			return getRuleContext(NnFishContext.class,0);
		}
		public EndQues02Context endQues02() {
			return getRuleContext(EndQues02Context.class,0);
		}
		public CaringContext caring() {
			return getRuleContext(CaringContext.class,0);
		}
		public CultureTechContext cultureTech() {
			return getRuleContext(CultureTechContext.class,0);
		}
		public QuestionWh20Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_questionWh20; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestionWh20(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestionWh20(this);
		}
	}

	public final QuestionWh20Context questionWh20() throws RecognitionException {
		QuestionWh20Context _localctx = new QuestionWh20Context(_ctx, getState());
		enterRule(_localctx, 182, RULE_questionWh20);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(657); verbPharseStartQues3();
			setState(661);
			switch (_input.LA(1)) {
			case 41:
			case 47:
			case 82:
				{
				setState(658); designAquarium();
				}
				break;
			case 15:
			case 37:
				{
				setState(659); caring();
				}
				break;
			case 46:
			case 76:
			case 86:
				{
				setState(660); cultureTech();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(663); nnFish();
			setState(664); nameFish();
			setState(665); endQues02();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuestionContext extends ParserRuleContext {
		public QuestionWh04Context questionWh04() {
			return getRuleContext(QuestionWh04Context.class,0);
		}
		public QuestionWh18Context questionWh18() {
			return getRuleContext(QuestionWh18Context.class,0);
		}
		public QuestionWh07Context questionWh07() {
			return getRuleContext(QuestionWh07Context.class,0);
		}
		public QuestionWh08Context questionWh08() {
			return getRuleContext(QuestionWh08Context.class,0);
		}
		public QuestionWh01Context questionWh01() {
			return getRuleContext(QuestionWh01Context.class,0);
		}
		public QuestionWh11Context questionWh11() {
			return getRuleContext(QuestionWh11Context.class,0);
		}
		public QuestionWh02Context questionWh02() {
			return getRuleContext(QuestionWh02Context.class,0);
		}
		public QuestionWh17Context questionWh17() {
			return getRuleContext(QuestionWh17Context.class,0);
		}
		public QuestionWh06Context questionWh06() {
			return getRuleContext(QuestionWh06Context.class,0);
		}
		public QuestionWh14Context questionWh14() {
			return getRuleContext(QuestionWh14Context.class,0);
		}
		public QuestionWh12Context questionWh12() {
			return getRuleContext(QuestionWh12Context.class,0);
		}
		public QuestionWh03Context questionWh03() {
			return getRuleContext(QuestionWh03Context.class,0);
		}
		public QuestionWh05Context questionWh05() {
			return getRuleContext(QuestionWh05Context.class,0);
		}
		public QuestionWh10Context questionWh10() {
			return getRuleContext(QuestionWh10Context.class,0);
		}
		public QuestionWh13Context questionWh13() {
			return getRuleContext(QuestionWh13Context.class,0);
		}
		public QuestionWh20Context questionWh20() {
			return getRuleContext(QuestionWh20Context.class,0);
		}
		public QuestionWh09Context questionWh09() {
			return getRuleContext(QuestionWh09Context.class,0);
		}
		public QuestionWh15Context questionWh15() {
			return getRuleContext(QuestionWh15Context.class,0);
		}
		public QuestionWh16Context questionWh16() {
			return getRuleContext(QuestionWh16Context.class,0);
		}
		public QuestionWh19Context questionWh19() {
			return getRuleContext(QuestionWh19Context.class,0);
		}
		public QuestionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_question; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).enterQuestion(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof quesListener ) ((quesListener)listener).exitQuestion(this);
		}
	}

	public final QuestionContext question() throws RecognitionException {
		QuestionContext _localctx = new QuestionContext(_ctx, getState());
		enterRule(_localctx, 184, RULE_question);
		try {
			setState(687);
			switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(667); questionWh01();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(668); questionWh02();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(669); questionWh03();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(670); questionWh04();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(671); questionWh05();
				}
				break;

			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(672); questionWh06();
				}
				break;

			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(673); questionWh07();
				}
				break;

			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(674); questionWh08();
				}
				break;

			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(675); questionWh09();
				}
				break;

			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(676); questionWh10();
				}
				break;

			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(677); questionWh11();
				}
				break;

			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(678); questionWh12();
				}
				break;

			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(679); questionWh13();
				}
				break;

			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(680); questionWh14();
				}
				break;

			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(681); questionWh15();
				}
				break;

			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(682); questionWh16();
				}
				break;

			case 17:
				enterOuterAlt(_localctx, 17);
				{
				setState(683); questionWh17();
				}
				break;

			case 18:
				enterOuterAlt(_localctx, 18);
				{
				setState(684); questionWh18();
				}
				break;

			case 19:
				enterOuterAlt(_localctx, 19);
				{
				setState(685); questionWh19();
				}
				break;

			case 20:
				enterOuterAlt(_localctx, 20);
				{
				setState(686); questionWh20();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3_\u02b4\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\3\2\3\2"+
		"\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u00cf"+
		"\n\b\3\t\3\t\3\n\3\n\3\13\3\13\3\f\3\f\3\r\3\r\3\r\3\r\5\r\u00dd\n\r\3"+
		"\16\3\16\3\17\3\17\3\20\3\20\3\21\3\21\3\21\5\21\u00e8\n\21\3\22\3\22"+
		"\3\23\3\23\3\24\3\24\3\25\3\25\3\25\5\25\u00f3\n\25\3\26\3\26\3\27\3\27"+
		"\3\30\3\30\3\31\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36"+
		"\3\37\3\37\3 \3 \3!\3!\3\"\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(\3(\3"+
		")\3)\3*\3*\3+\3+\3,\3,\3-\3-\3.\3.\3/\3/\3\60\3\60\3\61\3\61\3\62\3\62"+
		"\3\63\3\63\3\64\3\64\3\65\3\65\3\66\3\66\3\67\3\67\38\38\58\u013b\n8\3"+
		"9\39\3:\3:\3;\3;\3<\3<\3=\5=\u0146\n=\3=\3=\3>\3>\3?\3?\3?\3@\3@\3A\3"+
		"A\3A\3B\3B\3B\3C\3C\3C\3D\3D\3D\3E\3E\3E\3F\3F\3F\3G\6G\u0164\nG\rG\16"+
		"G\u0165\3G\6G\u0169\nG\rG\16G\u016a\5G\u016d\nG\3H\3H\3H\3H\3H\3H\3H\3"+
		"H\3H\3H\3H\5H\u017a\nH\3I\3I\3I\5I\u017f\nI\3J\3J\5J\u0183\nJ\3J\3J\5"+
		"J\u0187\nJ\3J\3J\3J\3J\3K\3K\5K\u018f\nK\3K\3K\3K\3K\5K\u0195\nK\3K\5"+
		"K\u0198\nK\3K\3K\3K\3K\3L\5L\u019f\nL\3L\3L\3L\3L\3L\3L\3L\3L\5L\u01a9"+
		"\nL\3M\5M\u01ac\nM\3M\3M\3M\3M\3M\3M\3N\5N\u01b5\nN\3N\3N\5N\u01b9\nN"+
		"\3N\3N\3N\5N\u01be\nN\3N\3N\3N\3O\5O\u01c4\nO\3O\5O\u01c7\nO\3O\3O\3O"+
		"\3O\3O\3O\3O\3O\5O\u01d1\nO\3P\5P\u01d4\nP\3P\3P\3P\3P\3P\5P\u01db\nP"+
		"\3P\3P\5P\u01df\nP\3Q\5Q\u01e2\nQ\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u01ea\nQ\3R\3R"+
		"\5R\u01ee\nR\3R\3R\5R\u01f2\nR\3R\5R\u01f5\nR\3R\3R\3R\3R\5R\u01fb\nR"+
		"\3S\5S\u01fe\nS\3S\3S\3S\3S\3S\5S\u0205\nS\3S\3S\3S\3T\5T\u020b\nT\3T"+
		"\3T\3T\3T\3T\5T\u0212\nT\3T\3T\3T\3U\5U\u0218\nU\3U\3U\3U\3U\3U\5U\u021f"+
		"\nU\3U\3U\3V\5V\u0224\nV\3V\3V\3V\3V\3V\3V\3V\3W\5W\u022e\nW\3W\3W\5W"+
		"\u0232\nW\3W\3W\3W\3W\3W\3X\5X\u023a\nX\3X\3X\3X\3X\3X\3X\3X\3X\3X\3Y"+
		"\5Y\u0246\nY\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u024f\nY\3Y\3Y\5Y\u0253\nY\3Z\5Z"+
		"\u0256\nZ\3Z\3Z\3Z\5Z\u025b\nZ\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u0263\nZ\3Z\3Z\5Z"+
		"\u0267\nZ\3[\3[\5[\u026b\n[\3[\5[\u026e\n[\3[\3[\5[\u0272\n[\3[\5[\u0275"+
		"\n[\3[\3[\3[\3[\3[\3[\5[\u027d\n[\3\\\5\\\u0280\n\\\3\\\3\\\3\\\5\\\u0285"+
		"\n\\\3\\\5\\\u0288\n\\\3\\\3\\\3\\\3\\\5\\\u028e\n\\\3\\\3\\\5\\\u0292"+
		"\n\\\3]\3]\3]\3]\5]\u0298\n]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3^\3^\3^\3"+
		"^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\5^\u02b2\n^\3^\2\2_\2\4\6\b\n\f\16\20"+
		"\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhj"+
		"lnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092"+
		"\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa"+
		"\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\2\31\4\2\34\34YY\4\2"+
		"))AA\4\2\13\13\17\17\5\2((99??\4\2\26\26\36\36\4\2\23\23MM\4\2  QQ\4\2"+
		"FFVV\t\2\t\n\35\35,-\64\65KKRRUU\5\2++\61\61TT\4\288CC\4\2\21\21\'\'\4"+
		"\2==BB\4\2\6\6@@\5\2\60\60NNXX\4\2\"\"&&\4\2%%GG\4\2\32\32\63\63\4\2\b"+
		"\b//\4\2\25\25\30\30\4\2\7\7\37\37\4\2$$>>\3\2]^\u02c8\2\u00bc\3\2\2\2"+
		"\4\u00be\3\2\2\2\6\u00c0\3\2\2\2\b\u00c2\3\2\2\2\n\u00c4\3\2\2\2\f\u00c6"+
		"\3\2\2\2\16\u00ce\3\2\2\2\20\u00d0\3\2\2\2\22\u00d2\3\2\2\2\24\u00d4\3"+
		"\2\2\2\26\u00d6\3\2\2\2\30\u00dc\3\2\2\2\32\u00de\3\2\2\2\34\u00e0\3\2"+
		"\2\2\36\u00e2\3\2\2\2 \u00e7\3\2\2\2\"\u00e9\3\2\2\2$\u00eb\3\2\2\2&\u00ed"+
		"\3\2\2\2(\u00f2\3\2\2\2*\u00f4\3\2\2\2,\u00f6\3\2\2\2.\u00f8\3\2\2\2\60"+
		"\u00fa\3\2\2\2\62\u00fc\3\2\2\2\64\u00fe\3\2\2\2\66\u0100\3\2\2\28\u0102"+
		"\3\2\2\2:\u0104\3\2\2\2<\u0106\3\2\2\2>\u0108\3\2\2\2@\u010a\3\2\2\2B"+
		"\u010c\3\2\2\2D\u010e\3\2\2\2F\u0110\3\2\2\2H\u0112\3\2\2\2J\u0114\3\2"+
		"\2\2L\u0116\3\2\2\2N\u0118\3\2\2\2P\u011a\3\2\2\2R\u011c\3\2\2\2T\u011e"+
		"\3\2\2\2V\u0120\3\2\2\2X\u0122\3\2\2\2Z\u0124\3\2\2\2\\\u0126\3\2\2\2"+
		"^\u0128\3\2\2\2`\u012a\3\2\2\2b\u012c\3\2\2\2d\u012e\3\2\2\2f\u0130\3"+
		"\2\2\2h\u0132\3\2\2\2j\u0134\3\2\2\2l\u0136\3\2\2\2n\u0138\3\2\2\2p\u013c"+
		"\3\2\2\2r\u013e\3\2\2\2t\u0140\3\2\2\2v\u0142\3\2\2\2x\u0145\3\2\2\2z"+
		"\u0149\3\2\2\2|\u014b\3\2\2\2~\u014e\3\2\2\2\u0080\u0150\3\2\2\2\u0082"+
		"\u0153\3\2\2\2\u0084\u0156\3\2\2\2\u0086\u0159\3\2\2\2\u0088\u015c\3\2"+
		"\2\2\u008a\u015f\3\2\2\2\u008c\u016c\3\2\2\2\u008e\u0179\3\2\2\2\u0090"+
		"\u017e\3\2\2\2\u0092\u0182\3\2\2\2\u0094\u018e\3\2\2\2\u0096\u019e\3\2"+
		"\2\2\u0098\u01ab\3\2\2\2\u009a\u01b4\3\2\2\2\u009c\u01c3\3\2\2\2\u009e"+
		"\u01d3\3\2\2\2\u00a0\u01e1\3\2\2\2\u00a2\u01ed\3\2\2\2\u00a4\u01fd\3\2"+
		"\2\2\u00a6\u020a\3\2\2\2\u00a8\u0217\3\2\2\2\u00aa\u0223\3\2\2\2\u00ac"+
		"\u022d\3\2\2\2\u00ae\u0239\3\2\2\2\u00b0\u0245\3\2\2\2\u00b2\u0255\3\2"+
		"\2\2\u00b4\u026a\3\2\2\2\u00b6\u027f\3\2\2\2\u00b8\u0293\3\2\2\2\u00ba"+
		"\u02b1\3\2\2\2\u00bc\u00bd\7\4\2\2\u00bd\3\3\2\2\2\u00be\u00bf\7H\2\2"+
		"\u00bf\5\3\2\2\2\u00c0\u00c1\t\2\2\2\u00c1\7\3\2\2\2\u00c2\u00c3\t\3\2"+
		"\2\u00c3\t\3\2\2\2\u00c4\u00c5\7\f\2\2\u00c5\13\3\2\2\2\u00c6\u00c7\7"+
		"O\2\2\u00c7\r\3\2\2\2\u00c8\u00cf\5\2\2\2\u00c9\u00cf\5\4\3\2\u00ca\u00cf"+
		"\5\6\4\2\u00cb\u00cf\5\b\5\2\u00cc\u00cf\5\n\6\2\u00cd\u00cf\5\f\7\2\u00ce"+
		"\u00c8\3\2\2\2\u00ce\u00c9\3\2\2\2\u00ce\u00ca\3\2\2\2\u00ce\u00cb\3\2"+
		"\2\2\u00ce\u00cc\3\2\2\2\u00ce\u00cd\3\2\2\2\u00cf\17\3\2\2\2\u00d0\u00d1"+
		"\7\62\2\2\u00d1\21\3\2\2\2\u00d2\u00d3\7#\2\2\u00d3\23\3\2\2\2\u00d4\u00d5"+
		"\7\33\2\2\u00d5\25\3\2\2\2\u00d6\u00d7\7I\2\2\u00d7\27\3\2\2\2\u00d8\u00dd"+
		"\5\20\t\2\u00d9\u00dd\5\22\n\2\u00da\u00dd\5\24\13\2\u00db\u00dd\5\26"+
		"\f\2\u00dc\u00d8\3\2\2\2\u00dc\u00d9\3\2\2\2\u00dc\u00da\3\2\2\2\u00dc"+
		"\u00db\3\2\2\2\u00dd\31\3\2\2\2\u00de\u00df\t\4\2\2\u00df\33\3\2\2\2\u00e0"+
		"\u00e1\t\5\2\2\u00e1\35\3\2\2\2\u00e2\u00e3\t\6\2\2\u00e3\37\3\2\2\2\u00e4"+
		"\u00e8\5\32\16\2\u00e5\u00e8\5\34\17\2\u00e6\u00e8\5\36\20\2\u00e7\u00e4"+
		"\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e7\u00e6\3\2\2\2\u00e8!\3\2\2\2\u00e9"+
		"\u00ea\t\7\2\2\u00ea#\3\2\2\2\u00eb\u00ec\t\b\2\2\u00ec%\3\2\2\2\u00ed"+
		"\u00ee\t\t\2\2\u00ee\'\3\2\2\2\u00ef\u00f3\5\"\22\2\u00f0\u00f3\5$\23"+
		"\2\u00f1\u00f3\5&\24\2\u00f2\u00ef\3\2\2\2\u00f2\u00f0\3\2\2\2\u00f2\u00f1"+
		"\3\2\2\2\u00f3)\3\2\2\2\u00f4\u00f5\t\n\2\2\u00f5+\3\2\2\2\u00f6\u00f7"+
		"\7\31\2\2\u00f7-\3\2\2\2\u00f8\u00f9\7\22\2\2\u00f9/\3\2\2\2\u00fa\u00fb"+
		"\7\3\2\2\u00fb\61\3\2\2\2\u00fc\u00fd\t\13\2\2\u00fd\63\3\2\2\2\u00fe"+
		"\u00ff\t\f\2\2\u00ff\65\3\2\2\2\u0100\u0101\t\r\2\2\u0101\67\3\2\2\2\u0102"+
		"\u0103\t\16\2\2\u01039\3\2\2\2\u0104\u0105\t\17\2\2\u0105;\3\2\2\2\u0106"+
		"\u0107\t\20\2\2\u0107=\3\2\2\2\u0108\u0109\t\21\2\2\u0109?\3\2\2\2\u010a"+
		"\u010b\t\22\2\2\u010bA\3\2\2\2\u010c\u010d\t\23\2\2\u010dC\3\2\2\2\u010e"+
		"\u010f\t\24\2\2\u010fE\3\2\2\2\u0110\u0111\t\25\2\2\u0111G\3\2\2\2\u0112"+
		"\u0113\7.\2\2\u0113I\3\2\2\2\u0114\u0115\7\24\2\2\u0115K\3\2\2\2\u0116"+
		"\u0117\7J\2\2\u0117M\3\2\2\2\u0118\u0119\7\66\2\2\u0119O\3\2\2\2\u011a"+
		"\u011b\7P\2\2\u011bQ\3\2\2\2\u011c\u011d\7T\2\2\u011dS\3\2\2\2\u011e\u011f"+
		"\7\r\2\2\u011fU\3\2\2\2\u0120\u0121\7*\2\2\u0121W\3\2\2\2\u0122\u0123"+
		"\7D\2\2\u0123Y\3\2\2\2\u0124\u0125\7\16\2\2\u0125[\3\2\2\2\u0126\u0127"+
		"\7<\2\2\u0127]\3\2\2\2\u0128\u0129\7\60\2\2\u0129_\3\2\2\2\u012a\u012b"+
		"\7;\2\2\u012ba\3\2\2\2\u012c\u012d\7E\2\2\u012dc\3\2\2\2\u012e\u012f\7"+
		"W\2\2\u012fe\3\2\2\2\u0130\u0131\7L\2\2\u0131g\3\2\2\2\u0132\u0133\7\5"+
		"\2\2\u0133i\3\2\2\2\u0134\u0135\7!\2\2\u0135k\3\2\2\2\u0136\u0137\t\26"+
		"\2\2\u0137m\3\2\2\2\u0138\u013a\7*\2\2\u0139\u013b\7$\2\2\u013a\u0139"+
		"\3\2\2\2\u013a\u013b\3\2\2\2\u013bo\3\2\2\2\u013c\u013d\7\27\2\2\u013d"+
		"q\3\2\2\2\u013e\u013f\t\27\2\2\u013fs\3\2\2\2\u0140\u0141\7:\2\2\u0141"+
		"u\3\2\2\2\u0142\u0143\7\20\2\2\u0143w\3\2\2\2\u0144\u0146\7*\2\2\u0145"+
		"\u0144\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u0148\7S"+
		"\2\2\u0148y\3\2\2\2\u0149\u014a\7;\2\2\u014a{\3\2\2\2\u014b\u014c\5n8"+
		"\2\u014c\u014d\7\67\2\2\u014d}\3\2\2\2\u014e\u014f\7\67\2\2\u014f\177"+
		"\3\2\2\2\u0150\u0151\5p9\2\u0151\u0152\7\67\2\2\u0152\u0081\3\2\2\2\u0153"+
		"\u0154\5t;\2\u0154\u0155\7\67\2\2\u0155\u0083\3\2\2\2\u0156\u0157\5v<"+
		"\2\u0157\u0158\7\67\2\2\u0158\u0085\3\2\2\2\u0159\u015a\5r:\2\u015a\u015b"+
		"\7\67\2\2\u015b\u0087\3\2\2\2\u015c\u015d\5x=\2\u015d\u015e\7\67\2\2\u015e"+
		"\u0089\3\2\2\2\u015f\u0160\5z>\2\u0160\u0161\7\67\2\2\u0161\u008b\3\2"+
		"\2\2\u0162\u0164\t\30\2\2\u0163\u0162\3\2\2\2\u0164\u0165\3\2\2\2\u0165"+
		"\u0163\3\2\2\2\u0165\u0166\3\2\2\2\u0166\u016d\3\2\2\2\u0167\u0169\7_"+
		"\2\2\u0168\u0167\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u0168\3\2\2\2\u016a"+
		"\u016b\3\2\2\2\u016b\u016d\3\2\2\2\u016c\u0163\3\2\2\2\u016c\u0168\3\2"+
		"\2\2\u016d\u008d\3\2\2\2\u016e\u017a\5\16\b\2\u016f\u017a\5\30\r\2\u0170"+
		"\u017a\5> \2\u0171\u017a\5\60\31\2\u0172\u017a\58\35\2\u0173\u017a\5>"+
		" \2\u0174\u017a\5:\36\2\u0175\u017a\5@!\2\u0176\u017a\5<\37\2\u0177\u017a"+
		"\5\64\33\2\u0178\u017a\5(\25\2\u0179\u016e\3\2\2\2\u0179\u016f\3\2\2\2"+
		"\u0179\u0170\3\2\2\2\u0179\u0171\3\2\2\2\u0179\u0172\3\2\2\2\u0179\u0173"+
		"\3\2\2\2\u0179\u0174\3\2\2\2\u0179\u0175\3\2\2\2\u0179\u0176\3\2\2\2\u0179"+
		"\u0177\3\2\2\2\u0179\u0178\3\2\2\2\u017a\u008f\3\2\2\2\u017b\u017f\5,"+
		"\27\2\u017c\u017f\5\62\32\2\u017d\u017f\5> \2\u017e\u017b\3\2\2\2\u017e"+
		"\u017c\3\2\2\2\u017e\u017d\3\2\2\2\u017f\u0091\3\2\2\2\u0180\u0183\5B"+
		"\"\2\u0181\u0183\5D#\2\u0182\u0180\3\2\2\2\u0182\u0181\3\2\2\2\u0182\u0183"+
		"\3\2\2\2\u0183\u0184\3\2\2\2\u0184\u0186\5\u008eH\2\u0185\u0187\5H%\2"+
		"\u0186\u0185\3\2\2\2\u0186\u0187\3\2\2\2\u0187\u0188\3\2\2\2\u0188\u0189"+
		"\5P)\2\u0189\u018a\5\u008cG\2\u018a\u018b\5|?\2\u018b\u0093\3\2\2\2\u018c"+
		"\u018f\5B\"\2\u018d\u018f\5D#\2\u018e\u018c\3\2\2\2\u018e\u018d\3\2\2"+
		"\2\u018e\u018f\3\2\2\2\u018f\u0194\3\2\2\2\u0190\u0195\5\u0090I\2\u0191"+
		"\u0195\5\u008eH\2\u0192\u0195\5\66\34\2\u0193\u0195\5.\30\2\u0194\u0190"+
		"\3\2\2\2\u0194\u0191\3\2\2\2\u0194\u0192\3\2\2\2\u0194\u0193\3\2\2\2\u0195"+
		"\u0197\3\2\2\2\u0196\u0198\5H%\2\u0197\u0196\3\2\2\2\u0197\u0198\3\2\2"+
		"\2\u0198\u0199\3\2\2\2\u0199\u019a\5P)\2\u019a\u019b\5\u008cG\2\u019b"+
		"\u019c\5~@\2\u019c\u0095\3\2\2\2\u019d\u019f\5B\"\2\u019e\u019d\3\2\2"+
		"\2\u019e\u019f\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1\5P)\2\u01a1\u01a2"+
		"\5\u008cG\2\u01a2\u01a3\5V,\2\u01a3\u01a8\5P)\2\u01a4\u01a9\5\u0080A\2"+
		"\u01a5\u01a9\5~@\2\u01a6\u01a9\5\u0082B\2\u01a7\u01a9\5\u0086D\2\u01a8"+
		"\u01a4\3\2\2\2\u01a8\u01a5\3\2\2\2\u01a8\u01a6\3\2\2\2\u01a8\u01a7\3\2"+
		"\2\2\u01a9\u0097\3\2\2\2\u01aa\u01ac\5B\"\2\u01ab\u01aa\3\2\2\2\u01ab"+
		"\u01ac\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\u01ae\5P)\2\u01ae\u01af\5\u008c"+
		"G\2\u01af\u01b0\5X-\2\u01b0\u01b1\5\u008eH\2\u01b1\u01b2\5|?\2\u01b2\u0099"+
		"\3\2\2\2\u01b3\u01b5\5B\"\2\u01b4\u01b3\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5"+
		"\u01b6\3\2\2\2\u01b6\u01b8\5P)\2\u01b7\u01b9\5r:\2\u01b8\u01b7\3\2\2\2"+
		"\u01b8\u01b9\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bb\5X-\2\u01bb\u01bd"+
		"\5\16\b\2\u01bc\u01be\5V,\2\u01bd\u01bc\3\2\2\2\u01bd\u01be\3\2\2\2\u01be"+
		"\u01bf\3\2\2\2\u01bf\u01c0\5\u008cG\2\u01c0\u01c1\5~@\2\u01c1\u009b\3"+
		"\2\2\2\u01c2\u01c4\5B\"\2\u01c3\u01c2\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4"+
		"\u01c6\3\2\2\2\u01c5\u01c7\5P)\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2"+
		"\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9\5\u008cG\2\u01c9\u01ca\5V,\2\u01ca"+
		"\u01cb\5\16\b\2\u01cb\u01cc\5H%\2\u01cc\u01d0\5P)\2\u01cd\u01d1\5~@\2"+
		"\u01ce\u01d1\5\u0082B\2\u01cf\u01d1\5\u0086D\2\u01d0\u01cd\3\2\2\2\u01d0"+
		"\u01ce\3\2\2\2\u01d0\u01cf\3\2\2\2\u01d1\u009d\3\2\2\2\u01d2\u01d4\5B"+
		"\"\2\u01d3\u01d2\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5"+
		"\u01d6\5P)\2\u01d6\u01d7\5\u008cG\2\u01d7\u01da\5X-\2\u01d8\u01db\5\u008e"+
		"H\2\u01d9\u01db\5\u0090I\2\u01da\u01d8\3\2\2\2\u01da\u01d9\3\2\2\2\u01db"+
		"\u01de\3\2\2\2\u01dc\u01df\5\u0084C\2\u01dd\u01df\5\u0080A\2\u01de\u01dc"+
		"\3\2\2\2\u01de\u01dd\3\2\2\2\u01df\u009f\3\2\2\2\u01e0\u01e2\5B\"\2\u01e1"+
		"\u01e0\3\2\2\2\u01e1\u01e2\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\u01e4\5P"+
		")\2\u01e4\u01e5\5\u008cG\2\u01e5\u01e6\5Z.\2\u01e6\u01e9\5(\25\2\u01e7"+
		"\u01ea\5\u0082B\2\u01e8\u01ea\5\u0086D\2\u01e9\u01e7\3\2\2\2\u01e9\u01e8"+
		"\3\2\2\2\u01ea\u00a1\3\2\2\2\u01eb\u01ee\5B\"\2\u01ec\u01ee\5D#\2\u01ed"+
		"\u01eb\3\2\2\2\u01ed\u01ec\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee\u01f1\3\2"+
		"\2\2\u01ef\u01f2\5\u008eH\2\u01f0\u01f2\5\u0090I\2\u01f1\u01ef\3\2\2\2"+
		"\u01f1\u01f0\3\2\2\2\u01f2\u01f4\3\2\2\2\u01f3\u01f5\5H%\2\u01f4\u01f3"+
		"\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f7\5P)\2\u01f7"+
		"\u01fa\5\u008cG\2\u01f8\u01fb\5\u0084C\2\u01f9\u01fb\5\u0080A\2\u01fa"+
		"\u01f8\3\2\2\2\u01fa\u01f9\3\2\2\2\u01fb\u00a3\3\2\2\2\u01fc\u01fe\5B"+
		"\"\2\u01fd\u01fc\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff"+
		"\u0200\5P)\2\u0200\u0201\5\u008cG\2\u0201\u0204\5X-\2\u0202\u0205\5,\27"+
		"\2\u0203\u0205\5\60\31\2\u0204\u0202\3\2\2\2\u0204\u0203\3\2\2\2\u0205"+
		"\u0206\3\2\2\2\u0206\u0207\5j\66\2\u0207\u0208\5~@\2\u0208\u00a5\3\2\2"+
		"\2\u0209\u020b\5B\"\2\u020a\u0209\3\2\2\2\u020a\u020b\3\2\2\2\u020b\u020c"+
		"\3\2\2\2\u020c\u020d\5P)\2\u020d\u020e\5\u008cG\2\u020e\u0211\5X-\2\u020f"+
		"\u0212\5,\27\2\u0210\u0212\5.\30\2\u0211\u020f\3\2\2\2\u0211\u0210\3\2"+
		"\2\2\u0212\u0213\3\2\2\2\u0213\u0214\5l\67\2\u0214\u0215\5~@\2\u0215\u00a7"+
		"\3\2\2\2\u0216\u0218\5B\"\2\u0217\u0216\3\2\2\2\u0217\u0218\3\2\2\2\u0218"+
		"\u0219\3\2\2\2\u0219\u021a\5P)\2\u021a\u021b\5\u008cG\2\u021b\u021e\5"+
		"X-\2\u021c\u021f\5 \21\2\u021d\u021f\5*\26\2\u021e\u021c\3\2\2\2\u021e"+
		"\u021d\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u0221\5\u0088E\2\u0221\u00a9"+
		"\3\2\2\2\u0222\u0224\5B\"\2\u0223\u0222\3\2\2\2\u0223\u0224\3\2\2\2\u0224"+
		"\u0225\3\2\2\2\u0225\u0226\5P)\2\u0226\u0227\5\u008cG\2\u0227\u0228\5"+
		"\\/\2\u0228\u0229\5J&\2\u0229\u022a\5 \21\2\u022a\u022b\5\u0088E\2\u022b"+
		"\u00ab\3\2\2\2\u022c\u022e\5B\"\2\u022d\u022c\3\2\2\2\u022d\u022e\3\2"+
		"\2\2\u022e\u022f\3\2\2\2\u022f\u0231\5 \21\2\u0230\u0232\5f\64\2\u0231"+
		"\u0230\3\2\2\2\u0231\u0232\3\2\2\2\u0232\u0233\3\2\2\2\u0233\u0234\5^"+
		"\60\2\u0234\u0235\5P)\2\u0235\u0236\5\u008cG\2\u0236\u0237\5\u0088E\2"+
		"\u0237\u00ad\3\2\2\2\u0238\u023a\5B\"\2\u0239\u0238\3\2\2\2\u0239\u023a"+
		"\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023c\5P)\2\u023c\u023d\5\u008cG\2"+
		"\u023d\u023e\5\\/\2\u023e\u023f\5J&\2\u023f\u0240\5T+\2\u0240\u0241\5"+
		"X-\2\u0241\u0242\5 \21\2\u0242\u0243\5\u0088E\2\u0243\u00af\3\2\2\2\u0244"+
		"\u0246\5B\"\2\u0245\u0244\3\2\2\2\u0245\u0246\3\2\2\2\u0246\u0247\3\2"+
		"\2\2\u0247\u0248\5P)\2\u0248\u0249\5\u008cG\2\u0249\u024e\5`\61\2\u024a"+
		"\u024f\5\66\34\2\u024b\u024f\5\62\32\2\u024c\u024f\5<\37\2\u024d\u024f"+
		"\5\30\r\2\u024e\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2"+
		"\u024e\u024d\3\2\2\2\u024f\u0252\3\2\2\2\u0250\u0253\5\u0084C\2\u0251"+
		"\u0253\5\u0080A\2\u0252\u0250\3\2\2\2\u0252\u0251\3\2\2\2\u0253\u00b1"+
		"\3\2\2\2\u0254\u0256\5B\"\2\u0255\u0254\3\2\2\2\u0255\u0256\3\2\2\2\u0256"+
		"\u0257\3\2\2\2\u0257\u0258\5R*\2\u0258\u025a\5^\60\2\u0259\u025b\5H%\2"+
		"\u025a\u0259\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025c\3\2\2\2\u025c\u025d"+
		"\5P)\2\u025d\u025e\5\u008cG\2\u025e\u0262\5X-\2\u025f\u0263\5\62\32\2"+
		"\u0260\u0263\5\30\r\2\u0261\u0263\5 \21\2\u0262\u025f\3\2\2\2\u0262\u0260"+
		"\3\2\2\2\u0262\u0261\3\2\2\2\u0263\u0266\3\2\2\2\u0264\u0267\5\u0084C"+
		"\2\u0265\u0267\5\u0080A\2\u0266\u0264\3\2\2\2\u0266\u0265\3\2\2\2\u0267"+
		"\u00b3\3\2\2\2\u0268\u026b\5B\"\2\u0269\u026b\5D#\2\u026a\u0268\3\2\2"+
		"\2\u026a\u0269\3\2\2\2\u026a\u026b\3\2\2\2\u026b\u026d\3\2\2\2\u026c\u026e"+
		"\5h\65\2\u026d\u026c\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u026f\3\2\2\2\u026f"+
		"\u0271\5\64\33\2\u0270\u0272\5r:\2\u0271\u0270\3\2\2\2\u0271\u0272\3\2"+
		"\2\2\u0272\u0274\3\2\2\2\u0273\u0275\5L\'\2\u0274\u0273\3\2\2\2\u0274"+
		"\u0275\3\2\2\2\u0275\u0276\3\2\2\2\u0276\u0277\5N(\2\u0277\u0278\5P)\2"+
		"\u0278\u0279\5\u008cG\2\u0279\u027c\5b\62\2\u027a\u027d\5~@\2\u027b\u027d"+
		"\5\u008aF\2\u027c\u027a\3\2\2\2\u027c\u027b\3\2\2\2\u027d\u00b5\3\2\2"+
		"\2\u027e\u0280\5B\"\2\u027f\u027e\3\2\2\2\u027f\u0280\3\2\2\2\u0280\u0281"+
		"\3\2\2\2\u0281\u0282\5P)\2\u0282\u0284\5\u008cG\2\u0283\u0285\5d\63\2"+
		"\u0284\u0283\3\2\2\2\u0284\u0285\3\2\2\2\u0285\u0287\3\2\2\2\u0286\u0288"+
		"\5z>\2\u0287\u0286\3\2\2\2\u0287\u0288\3\2\2\2\u0288\u028d\3\2\2\2\u0289"+
		"\u028e\5\66\34\2\u028a\u028e\5<\37\2\u028b\u028e\5\62\32\2\u028c\u028e"+
		"\5\64\33\2\u028d\u0289\3\2\2\2\u028d\u028a\3\2\2\2\u028d\u028b\3\2\2\2"+
		"\u028d\u028c\3\2\2\2\u028e\u0291\3\2\2\2\u028f\u0292\5\u0084C\2\u0290"+
		"\u0292\5\u0080A\2\u0291\u028f\3\2\2\2\u0291\u0290\3\2\2\2\u0292\u00b7"+
		"\3\2\2\2\u0293\u0297\5F$\2\u0294\u0298\5\62\32\2\u0295\u0298\5\66\34\2"+
		"\u0296\u0298\5<\37\2\u0297\u0294\3\2\2\2\u0297\u0295\3\2\2\2\u0297\u0296"+
		"\3\2\2\2\u0298\u0299\3\2\2\2\u0299\u029a\5P)\2\u029a\u029b\5\u008cG\2"+
		"\u029b\u029c\5~@\2\u029c\u00b9\3\2\2\2\u029d\u02b2\5\u0092J\2\u029e\u02b2"+
		"\5\u0094K\2\u029f\u02b2\5\u0096L\2\u02a0\u02b2\5\u0098M\2\u02a1\u02b2"+
		"\5\u009aN\2\u02a2\u02b2\5\u009cO\2\u02a3\u02b2\5\u009eP\2\u02a4\u02b2"+
		"\5\u00a0Q\2\u02a5\u02b2\5\u00a2R\2\u02a6\u02b2\5\u00a4S\2\u02a7\u02b2"+
		"\5\u00a6T\2\u02a8\u02b2\5\u00a8U\2\u02a9\u02b2\5\u00aaV\2\u02aa\u02b2"+
		"\5\u00acW\2\u02ab\u02b2\5\u00aeX\2\u02ac\u02b2\5\u00b0Y\2\u02ad\u02b2"+
		"\5\u00b2Z\2\u02ae\u02b2\5\u00b4[\2\u02af\u02b2\5\u00b6\\\2\u02b0\u02b2"+
		"\5\u00b8]\2\u02b1\u029d\3\2\2\2\u02b1\u029e\3\2\2\2\u02b1\u029f\3\2\2"+
		"\2\u02b1\u02a0\3\2\2\2\u02b1\u02a1\3\2\2\2\u02b1\u02a2\3\2\2\2\u02b1\u02a3"+
		"\3\2\2\2\u02b1\u02a4\3\2\2\2\u02b1\u02a5\3\2\2\2\u02b1\u02a6\3\2\2\2\u02b1"+
		"\u02a7\3\2\2\2\u02b1\u02a8\3\2\2\2\u02b1\u02a9\3\2\2\2\u02b1\u02aa\3\2"+
		"\2\2\u02b1\u02ab\3\2\2\2\u02b1\u02ac\3\2\2\2\u02b1\u02ad\3\2\2\2\u02b1"+
		"\u02ae\3\2\2\2\u02b1\u02af\3\2\2\2\u02b1\u02b0\3\2\2\2\u02b2\u00bb\3\2"+
		"\2\2A\u00ce\u00dc\u00e7\u00f2\u013a\u0145\u0165\u016a\u016c\u0179\u017e"+
		"\u0182\u0186\u018e\u0194\u0197\u019e\u01a8\u01ab\u01b4\u01b8\u01bd\u01c3"+
		"\u01c6\u01d0\u01d3\u01da\u01de\u01e1\u01e9\u01ed\u01f1\u01f4\u01fa\u01fd"+
		"\u0204\u020a\u0211\u0217\u021e\u0223\u022d\u0231\u0239\u0245\u024e\u0252"+
		"\u0255\u025a\u0262\u0266\u026a\u026d\u0271\u0274\u027c\u027f\u0284\u0287"+
		"\u028d\u0291\u0297\u02b1";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}